Added new NamingProvider, SubstituteNamingProvider, which can store a…

… dictionary of generated names and an alternate to substitute with

- Updated the INamingProvider to add two specific Type-based methods for PropertyNameFromAttribute and PropertyNameFromElement, to ensure that custom implementors can split the implementation accordingly.
- Updated XmlSchemaClassGenerator.Console to take in command line options for --typeNameSubstitute and typeNameSubstituteFile.

What's left:

- Update README
- Add tests

XmlSchemaClassGenerator.Console/Program.cs

@@ -1,4 +1,5 @@
 using XmlSchemaClassGenerator;
+using XmlSchemaClassGenerator.NamingProviders;
 using System;
 using System.CodeDom;
 using System.Collections.Generic;
@@ -11,7 +12,7 @@
 using System.Threading.Tasks;
 using Mono.Options;
 using Ganss.IO;
-
+
 namespace XmlSchemaClassGenerator.Console
 {
  static class Program
@@ -20,6 +21,7 @@ static void Main(string[] args)
  {
  var showHelp = args.Length == 0;
  var namespaces = new List<string>();
+ var nameSubstitutes = new List<string>();
  var outputFolder = (string)null;
  Type integerType = null;
  var useIntegerTypeAsFallback = false;
@@ -59,6 +61,7 @@ static void Main(string[] args)
  var useArrayItemAttribute = true;
  var enumAsString = false;
  var namespaceFiles = new List<string>();
+ var nameSubstituteFiles = new List<string>();
 
  var options = new OptionSet {
  { "h|help", "show this message and exit", v => showHelp = v != null },
@@ -67,9 +70,16 @@ static void Main(string[] args)
 One option must be given for each namespace to be mapped.
 A file name may be given by appending a pipe sign (|) followed by a file name (like schema.xsd) to the XML namespace.
 If no mapping is found for an XML namespace, a name is generated automatically (may fail).", v => namespaces.Add(v) },
- { "nf|namespaceFile=", @"file containing mapppings from XML namespaces to C# namespaces
+ { "nf|namespaceFile=", @"file containing mappings from XML namespaces to C# namespaces
 The line format is one mapping per line: XML namespace = C# namespace [optional file name].
 Lines starting with # and empty lines are ignored.", v => namespaceFiles.Add(v) },
+ { "tns|typeNameSubstitute=", @"substitute a generated type/member name
+Separate type/member name and substitute name by '='.
+Prefix type/member name with an appropriate kind ID as documented at: https://t.ly/HHEI.
+Prefix with 'A:' to substitute any type/member.", v => nameSubstitutes.Add(v) },
+ { "tnsf|typeNameSubstituteFile=", @"file containing generated type/member name substitute mappings
+The line format is one mapping per line: prefixed type/member name = substitute name.
+Lines starting with # and empty lines are ignored.", v => nameSubstituteFiles.Add(v) },
  { "o|output=", "the {FOLDER} to write the resulting .cs files to", v => outputFolder = v },
  { "i|integer=", @"map xs:integer and derived types to {TYPE} instead of automatic approximation
 {TYPE} can be i[nt], l[ong], or d[ecimal]", v => {
@@ -178,6 +188,9 @@ A file name may be given by appending a pipe sign (|) followed by a file name (l
  return name;
  });
 
+ ParseNameSubstituteFiles(nameSubstitutes, nameSubstituteFiles);
+ var nameSubstituteMap = nameSubstitutes.ToDictionary();
+
  if (!string.IsNullOrEmpty(outputFolder))
  {
  outputFolder = Path.GetFullPath(outputFolder);
@@ -221,6 +234,11 @@ A file name may be given by appending a pipe sign (|) followed by a file name (l
  EnumAsString = enumAsString,
  };
 
+ if (nameSubstituteMap.Any())
+ {
+ generator.NamingProvider = new SubstituteNamingProvider(nameSubstituteMap);
+ }
+
  generator.CommentLanguages.AddRange(commentLanguages);
 
  if (pclCompatible)
@@ -265,6 +283,31 @@ private static void ParseNamespaceFiles(List<string> namespaces, List<string> na
  }
  }
 
+ private static void ParseNameSubstituteFiles(List<string> nameSubstitutes, List<string> nameSubstituteFiles)
+ {
+ foreach (var nameSubstituteFile in nameSubstituteFiles)
+ {
+ foreach (var (line, number) in File.ReadAllLines(nameSubstituteFile)
+ .Select((l, i) => (Line: l.Trim(), Number: i + 1))
+ .Where(l => !string.IsNullOrWhiteSpace(l.Line) && !l.Line.StartsWith("#")))
+ {
+ var parts = line.Split('=');
+
+ if (parts.Length != 2)
+ {
+ System.Console.WriteLine($"{nameSubstituteFile}:{number}: Line format is prefixed type/member name = substitute name");
+ Environment.Exit(2);
+ }
+
+ var generatedName = parts[0].Trim();
+ var substituteName = parts[1].Trim();
+ var nameSubstitute = $"{generatedName}={substituteName}";
+
+ nameSubstitutes.Add(nameSubstitute);
+ }
+ }
+ }
+
  static void ShowHelp(OptionSet p)
  {
  System.Console.WriteLine("Usage: xscgen [OPTIONS]+ xsdFile...");

XmlSchemaClassGenerator/EnumerableExtensions.cs

@@ -97,5 +97,23 @@ public static IEnumerable<NamespaceHierarchyItem> MarkAmbiguousNamespaceTypes(
  yield return hierarchyItem;
  }
  }
+
+ /// <summary>
+ /// Creates a <see cref="Dictionary{TKey,TValue}" /> from an <see cref="IEnumerable{T}" /> splitting the values into key and value pairs based on the <paramref name="delimiter"/>.
+ /// </summary>
+ /// <param name="source">An <see cref="IEnumerable{T}" /> to create a <see cref="Dictionary{TKey,TValue}" /> from.</param>
+ /// <param name="delimiter">An optional value that supplies the delimiter to use to create the key and value from the <paramref name="source"/>.</param>
+ /// <returns>A <see cref="Dictionary{TKey,TValue}" /> that contains keys and values. The values within each group are in the same order as in <paramref name="source" />.</returns>
+ public static Dictionary<string, string> ToDictionary(this IEnumerable<string> source, string delimiter = "=")
+ {
+ var result = new Dictionary<string, string>();
+ foreach (string value in source ?? Enumerable.Empty<string>())
+ {
+ var pair = value.Split(new string[] { delimiter ?? "=" }, 2, StringSplitOptions.None);
+ result.Add(pair[0], pair[1]);
+ }
+
+ return result;
+ }
  }
 }

XmlSchemaClassGenerator/INamingProvider.cs

@@ -23,6 +23,24 @@ public interface INamingProvider
  /// <returns>Name of the property</returns>
  string PropertyNameFromElement(string typeModelName, string elementName, XmlSchemaElement element);
 
+ /// <summary>
+ /// Creates a name for an inner type from an attribute name
+ /// </summary>
+ /// <param name="typeModelName">Name of the typeModel</param>
+ /// <param name="attributeName">Attribute name</param>
+ /// <param name="attribute">Original XSD attribute</param>
+ /// <returns>Name of the inner type</returns>
+ string TypeNameFromAttribute(string typeModelName, string attributeName, XmlSchemaAttribute attribute);
+
+ /// <summary>
+ /// Creates a name for an inner type from an element name
+ /// </summary>
+ /// <param name="typeModelName">Name of the typeModel</param>
+ /// <param name="elementName">Element name</param>
+ /// <param name="element">Original XSD element</param>
+ /// <returns>Name of the inner type</returns>
+ string TypeNameFromElement(string typeModelName, string elementName, XmlSchemaElement element);
+
  /// <summary>
  /// Creates a name for an enum member based on a value
  /// </summary>

XmlSchemaClassGenerator/ModelBuilder.cs

@@ -878,7 +878,7 @@ private PropertyModel PropertyFromAttribute(TypeModel owningTypeModel, XmlSchema
  if (attributeQualifiedName.IsEmpty || string.IsNullOrEmpty(attributeQualifiedName.Namespace))
  {
  // inner type, have to generate a type name
- var typeName = _configuration.NamingProvider.PropertyNameFromAttribute(owningTypeModel.Name, attribute.QualifiedName.Name, attribute);
+ var typeName = _configuration.NamingProvider.TypeNameFromAttribute(owningTypeModel.Name, attribute.QualifiedName.Name, attribute);
  attributeQualifiedName = new XmlQualifiedName(typeName, owningTypeModel.XmlSchemaName.Namespace);
  // try to avoid name clashes
  if (NameExists(attributeQualifiedName))
@@ -1024,7 +1024,7 @@ private XmlQualifiedName GetQualifiedName(TypeModel typeModel, XmlSchemaParticle
  {
  // inner type, have to generate a type name
  var typeModelName = xmlParticle is XmlSchemaGroupRef groupRef ? groupRef.RefName : typeModel.XmlSchemaName;
- var typeName = _configuration.NamingProvider.PropertyNameFromElement(typeModelName.Name, element.QualifiedName.Name, element);
+ var typeName = _configuration.NamingProvider.TypeNameFromElement(typeModelName.Name, element.QualifiedName.Name, element);
  elementQualifiedName = new XmlQualifiedName(typeName, typeModel.XmlSchemaName.Namespace);
  // try to avoid name clashes
  if (NameExists(elementQualifiedName))

XmlSchemaClassGenerator/NamingProvider.cs

@@ -1,6 +1,7 @@
 namespace XmlSchemaClassGenerator
 {
  using System.Xml;
+ using System.Xml.Linq;
  using System.Xml.Schema;
 
  /// <summary>
@@ -44,6 +45,14 @@ public virtual string PropertyNameFromElement(string typeModelName, string eleme
  return typeModelName.ToTitleCase(_namingScheme) + elementName.ToTitleCase(_namingScheme);
  }
 
+ /// <inheritdoc/>
+ public virtual string TypeNameFromAttribute(string typeModelName, string attributeName, XmlSchemaAttribute attribute)
+ => PropertyNameFromAttribute(typeModelName, attributeName, attribute);
+
+ /// <inheritdoc/>
+ public virtual string TypeNameFromElement(string typeModelName, string elementName, XmlSchemaElement element)
+ => PropertyNameFromElement(typeModelName, elementName, element);
+
  /// <summary>
  /// Creates a name for an enum member based on a value
  /// </summary>

XmlSchemaClassGenerator/NamingProviders/SubstituteNamingProvider.cs

@@ -0,0 +1,113 @@
+using System.Collections.Generic;
+using System.Xml;
+using System.Xml.Schema;
+
+namespace XmlSchemaClassGenerator.NamingProviders
+{
+ /// <summary>
+ /// Provides options to customize member names, and automatically substitute names for defined types/members.
+ /// </summary>
+ public class SubstituteNamingProvider
+ : NamingProvider, INamingProvider
+ {
+ private readonly Dictionary<string, string> _nameSubstitutes;
+
+ /// <inheritdoc cref="SubstituteNamingProvider(NamingScheme, Dictionary{string, string})"/>
+ public SubstituteNamingProvider(NamingScheme namingScheme)
+ : this(namingScheme, new())
+ {
+ }
+
+ /// <inheritdoc cref="SubstituteNamingProvider(NamingScheme, Dictionary{string, string})"/>
+ public SubstituteNamingProvider(Dictionary<string, string> nameSubstitutes)
+ : this(NamingScheme.PascalCase, nameSubstitutes)
+ {
+ }
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="SubstituteNamingProvider"/> class.
+ /// </summary>
+ /// <param name="namingScheme">The naming scheme.</param>
+ /// <param name="nameSubstitutes">
+ /// A dictionary containing name substitute pairs.
+ /// <para>
+ /// Keys need to be prefixed with an appropriate kind ID as documented at:
+ /// <see href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/documentation-comments#d42-id-string-format">https://t.ly/HHEI</see>.
+ /// </para>
+ /// <para>Prefix with <c>A:</c> to substitute any type/member.</para>
+ /// </param>
+ public SubstituteNamingProvider(NamingScheme namingScheme, Dictionary<string, string> nameSubstitutes)
+ : base(namingScheme)
+ {
+ _nameSubstitutes = nameSubstitutes;
+ }
+
+ /// <inheritdoc/>
+ public override string PropertyNameFromAttribute(string typeModelName, string attributeName, XmlSchemaAttribute attribute)
+ => SubstituteName("P", base.PropertyNameFromAttribute(typeModelName, attributeName, attribute));
+
+ /// <inheritdoc/>
+ public override string PropertyNameFromElement(string typeModelName, string elementName, XmlSchemaElement element)
+ => SubstituteName("P", base.PropertyNameFromElement(typeModelName, elementName, element));
+
+ /// <inheritdoc/>
+ public override string TypeNameFromAttribute(string typeModelName, string attributeName, XmlSchemaAttribute attribute)
+ => SubstituteName("T", base.PropertyNameFromAttribute(typeModelName, attributeName, attribute));
+
+ /// <inheritdoc/>
+ public override string TypeNameFromElement(string typeModelName, string elementName, XmlSchemaElement element)
+ => SubstituteName("T", base.PropertyNameFromElement(typeModelName, elementName, element));
+
+ /// <inheritdoc/>
+ public override string EnumMemberNameFromValue(string enumName, string value, XmlSchemaEnumerationFacet xmlFacet)
+ => SubstituteName($"T:{enumName}", base.EnumMemberNameFromValue(enumName, value, xmlFacet));
+
+ /// <inheritdoc/>
+ public override string ComplexTypeNameFromQualifiedName(XmlQualifiedName qualifiedName, XmlSchemaComplexType complexType)
+ => SubstituteName("T", base.ComplexTypeNameFromQualifiedName(qualifiedName, complexType));
+
+ /// <inheritdoc/>
+ public override string AttributeGroupTypeNameFromQualifiedName(XmlQualifiedName qualifiedName, XmlSchemaAttributeGroup attributeGroup)
+ => SubstituteName("T", base.AttributeGroupTypeNameFromQualifiedName(qualifiedName, attributeGroup));
+
+ /// <inheritdoc/>
+ public override string GroupTypeNameFromQualifiedName(XmlQualifiedName qualifiedName, XmlSchemaGroup group)
+ => SubstituteName("T", base.GroupTypeNameFromQualifiedName(qualifiedName, group));
+
+ /// <inheritdoc/>
+ public override string SimpleTypeNameFromQualifiedName(XmlQualifiedName qualifiedName, XmlSchemaSimpleType simpleType)
+ => SubstituteName("T", base.SimpleTypeNameFromQualifiedName(qualifiedName, simpleType));
+
+ /// <inheritdoc/>
+ public override string RootClassNameFromQualifiedName(XmlQualifiedName qualifiedName, XmlSchemaElement xmlElement)
+ => SubstituteName("T", base.RootClassNameFromQualifiedName(qualifiedName, xmlElement));
+
+ /// <inheritdoc/>
+ public override string EnumTypeNameFromQualifiedName(XmlQualifiedName qualifiedName, XmlSchemaSimpleType xmlSimpleType)
+ => SubstituteName("T", base.EnumTypeNameFromQualifiedName(qualifiedName, xmlSimpleType));
+
+ /// <inheritdoc/>
+ public override string AttributeNameFromQualifiedName(XmlQualifiedName qualifiedName, XmlSchemaAttribute xmlAttribute)
+ => SubstituteName("P", base.AttributeNameFromQualifiedName(qualifiedName, xmlAttribute));
+
+ /// <inheritdoc/>
+ public override string ElementNameFromQualifiedName(XmlQualifiedName qualifiedName, XmlSchemaElement xmlElement)
+ => SubstituteName("P", base.ElementNameFromQualifiedName(qualifiedName, xmlElement));
+
+ private string SubstituteName(string typeIdPrefix, string name)
+ {
+ if (string.IsNullOrWhiteSpace(name))
+ {
+ return name;
+ }
+
+ string substituteName;
+ if (_nameSubstitutes.TryGetValue($"{typeIdPrefix}:{name}", out substituteName) || _nameSubstitutes.TryGetValue($"A:{name}", out substituteName))
+ {
+ return substituteName;
+ }
+
+ return name;
+ }
+ }
+}