test(dry-generator): consolidate V2_6_V2_7 fixtures into topic-first layout with version gates

.config/dotnet-tools.json

@@ -7,6 +7,12 @@
       "commands": [
         "reportgenerator"
       ]
+    },
+    "dotnet-stryker": {
+      "version": "4.16.0",
+      "commands": [
+        "stryker"
+      ]
     }
   }
 }

MTConnect.NET.sln

@@ -143,6 +143,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MTConnect.NET-HTTP-Tests",
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MTConnect.NET-SysML-Tests", "tests\MTConnect.NET-SysML-Tests\MTConnect.NET-SysML-Tests.csproj", "{6CE969D2-A1E8-4BC1-85D8-303701B42F64}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MTConnect.NET-Generator-Tests", "tests\MTConnect.NET-Generator-Tests\MTConnect.NET-Generator-Tests.csproj", "{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -519,6 +521,14 @@ Global
 		{6CE969D2-A1E8-4BC1-85D8-303701B42F64}.Package|Any CPU.Build.0 = Debug|Any CPU
 		{6CE969D2-A1E8-4BC1-85D8-303701B42F64}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6CE969D2-A1E8-4BC1-85D8-303701B42F64}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}.Docker|Any CPU.ActiveCfg = Debug|Any CPU
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}.Docker|Any CPU.Build.0 = Debug|Any CPU
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}.Package|Any CPU.ActiveCfg = Debug|Any CPU
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}.Package|Any CPU.Build.0 = Debug|Any CPU
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -576,7 +586,7 @@ Global
 		{17E64F59-0E62-4FCE-BEC4-EABBCF95B9A2} = {BBF53739-168D-4635-8595-083AC0C65E4C}
 		{AE09D1CA-5572-40BF-B984-74230E8634E1} = {14375E03-6BF8-45E6-B868-D2399368992B}
 		{3E89B860-A428-470C-8E48-0DDABC4027F0} = {14375E03-6BF8-45E6-B868-D2399368992B}
-		{6CE969D2-A1E8-4BC1-85D8-303701B42F64} = {14375E03-6BF8-45E6-B868-D2399368992B}
+		{8B61CE3B-DC8A-47CE-A34B-38BC57DFFD57} = {14375E03-6BF8-45E6-B868-D2399368992B}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {CC13D3AD-18BF-4695-AB2A-087EF0885B20}

build/MTConnect.NET-DocsGen/CliInventory.cs

@@ -342,10 +342,15 @@ private static CliInfo CollectDotNetTool(string name, string file, string repoRo
             if (headerDescs.TryGetValue(flagName, out var headerDesc)) desc = headerDesc;
             desc ??= ExtractDotnetFlagDescription(text, flagName);
 
-            // Detect whether the case body calls `RequireValue` — if it
-            // does, the flag takes a value.
+            // Detect whether the case body calls `RequireValue` — if it does,
+            // the flag takes a value. The scan is bounded to the CURRENT case
+            // block only: it stops at the next `case "…":` label, a `default:`
+            // label, or a `break;` terminator, so a boolean flag whose case
+            // body sits above a value-taking case (like `--full-tree` above
+            // `case "--output": … RequireValue(…)`) does not falsely inherit
+            // the neighbor's value shape.
             bool takesValue = Regex.IsMatch(text,
-                $@"case\s+""{Regex.Escape(flagName)}""\s*:[\s\S]{{0,200}}?RequireValue");
+                $@"case\s+""{Regex.Escape(flagName)}""\s*:(?:(?!\s*case\s+""|\s*default\s*:|\bbreak\s*;)[\s\S])*?RequireValue");
             flags.Add(new CliFlag(
                 Name: flagName,
                 Short: null,

build/MTConnect.NET-SysML-Import/CSharp/ClassModel.cs

@@ -75,6 +75,22 @@ public class ClassModel : MTConnectClassModel, ITemplateModel
         /// </summary>
         public new List<PropertyModel> Properties { get; set; } = new();
 
+        /// <summary>
+        /// <c>true</c> when at least one ancestor in the
+        /// <see cref="MTConnectClassModel.ParentName"/> chain declares a
+        /// non-empty <see cref="MTConnectClassModel.Rules"/> array.
+        /// <c>Model.scriban</c> uses this — rather than mere parent
+        /// presence — to decide whether the generated <c>Rules</c> field
+        /// needs the <c>new</c> modifier. A class can have a parent
+        /// without that parent (or any of its ancestors) declaring
+        /// <c>Rules</c>, in which case emitting <c>new</c> hides nothing
+        /// and the compiler raises CS0109. Populated by
+        /// <see cref="CSharpTemplateRenderer"/> after every
+        /// <see cref="ClassModel"/> has been assembled, so the full
+        /// ancestor chain is resolvable.
+        /// </summary>
+        public bool ParentHasRules { get; set; }
+
 
         /// <summary>
         /// Parameterless constructor used by the import pipeline when it

build/MTConnect.NET-SysML-Import/CSharp/EnumModel.cs

@@ -93,7 +93,7 @@ public string RenderModel()
         public string RenderDescriptions()
         {
             if (Values == null || Values.Count == 0) return null;
-            var template = TemplateLoader.LoadOrThrow("CSharp", "Templates", "EnumDescriptions.scriban");
+            var template = TemplateLoader.LoadOrThrow("CSharp", "Templates", "EnumOrStringDescriptions.scriban");
             return template.Render(this);
         }
     }

build/MTConnect.NET-SysML-Import/CSharp/EnumStringModel.cs

@@ -14,6 +14,14 @@ internal class EnumStringModel : MTConnectEnumModel, ITemplateModel
 
         public bool IsPartial { get; set; }
 
+        // Consumed by the Shape-B consolidated EnumOrStringDescriptions.scriban
+        // template: gates the class-doc wording, the Get(...) overload's
+        // parameter type (string vs. enum-typed), and the Get(...) doc summary.
+        // EnumModel and ObservationModel do NOT expose this — Scriban resolves
+        // a missing member as null (falsy), producing the enum-shape emission
+        // for those two callers.
+        public bool IsString => true;
+
 
         public EnumStringModel() { }
 
@@ -88,7 +96,7 @@ public string RenderModel()
 
         public string RenderDescriptions()
         {
-            var template = TemplateLoader.LoadOrThrow("CSharp", "Templates", "EnumStringDescriptions.scriban");
+            var template = TemplateLoader.LoadOrThrow("CSharp", "Templates", "EnumOrStringDescriptions.scriban");
             return template.Render(this);
         }
     }

build/MTConnect.NET-SysML-Import/CSharp/MeasurementModel.cs

@@ -66,7 +66,11 @@ public string RenderModel()
         }
 
         /// <inheritdoc />
-        public string RenderInterface() => null;
+        public string RenderInterface()
+        {
+            var template = TemplateLoader.LoadOrThrow("CSharp", "Templates", "Pallets.MeasurementInterface.scriban");
+            return template.Render(this);
+        }
 
         /// <inheritdoc />
         public string RenderDescriptions() => null;

build/MTConnect.NET-SysML-Import/CSharp/ObservationModel.cs

@@ -72,7 +72,7 @@ public string RenderModel()
         /// <inheritdoc />
         public string RenderDescriptions()
         {
-            var template = TemplateLoader.LoadOrThrow("CSharp", "Templates", "EnumDescriptions.scriban");
+            var template = TemplateLoader.LoadOrThrow("CSharp", "Templates", "EnumOrStringDescriptions.scriban");
             return template.Render(this);
         }
     }

build/MTConnect.NET-SysML-Import/CSharp/TemplateRenderer.cs

@@ -306,6 +306,15 @@ public static void Render(MTConnectModel mtconnectModel, string outputPath)
                         // so its `Code` property hides Measurement.Code and needs `new`.
                         MarkInheritedProperties(templates, classModels);
 
+                        // Mark each ClassModel's ParentHasRules flag so Model.scriban
+                        // emits the `new` modifier on the generated Rules[] field only
+                        // when an ancestor actually declares Rules. Parent presence
+                        // alone is not sufficient — e.g. Axis extends AbstractAxis, but
+                        // AbstractAxis has no Rules, so `new` on Axis.Rules would hide
+                        // nothing and raise CS0109 ("does not hide an accessible
+                        // member"). See ClassModel.ParentHasRules XML doc.
+                        MarkParentHasRules(templates, classModels);
+
 
                         foreach (var template in templates)
                         {
@@ -642,20 +651,19 @@ private static void MarkInheritedProperties(
                         break;
 
                     case "Assets.CuttingTools.ToolingMeasurement":
-                        // ToolingMeasurement extends `Measurement` (the
-                        // CuttingTools abstract Measurement base, NOT
-                        // Assets.Pallet.Measurement). The CuttingTools
-                        // Measurement.g.cs is hand-maintained / frozen —
-                        // not produced by any current renderer flow — so
-                        // it never enters the export-side ClassModel
-                        // graph the inheritance walk traverses, and a
-                        // Name-only lookup of "Measurement" resolves to
-                        // Pallet.Measurement (which lacks Code). Class
-                        // side only — IMeasurement.g.cs has `Code`
-                        // commented out, so the interface child does NOT
-                        // hide anything and emitting `new` there would
-                        // produce CS0109 instead.
-                        classOnlyNames.Add("Code");
+                        // No hand-stitched inheritance seed needed. The
+                        // Assets.CuttingTools.Measurement base IS produced
+                        // by the current renderer flow (via
+                        // MTConnectAssetInformationModel.ParseAssetInformationModel's
+                        // sharedMeasurement injection which imports the
+                        // Pallet Measurement class under Assets.CuttingTools),
+                        // so the export-side ClassModel graph already carries
+                        // its property list. The Pallet Measurement lacks
+                        // Code, and the interface IMeasurement.g.cs likewise
+                        // has Code commented out — hence emitting `new` on
+                        // ToolingMeasurement.Code would raise CS0109 on both
+                        // the class and interface sides. Fall through to the
+                        // default inheritance walk with no override.
                         break;
                 }
 
@@ -701,6 +709,82 @@ private static void MarkInheritedProperties(
             }
         }
 
+        /// <summary>
+        /// Marks each <see cref="ClassModel.ParentHasRules"/> flag by walking
+        /// the <see cref="MTConnectClassModel.ParentName"/> ancestor chain and
+        /// checking whether any ancestor declares a non-empty
+        /// <see cref="MTConnectClassModel.Rules"/> array. <c>Model.scriban</c>
+        /// uses the flag to decide whether the generated <c>Rules</c> field
+        /// needs the <c>new</c> modifier — mere parent presence is not
+        /// sufficient, since a class can extend a parent that itself carries
+        /// no <c>Rules</c> (e.g. <c>Axis : AbstractAxis</c>, where
+        /// <c>AbstractAxis</c> has no <c>Rules</c>). Emitting <c>new</c> in
+        /// that case hides nothing and the compiler raises CS0109.
+        /// </summary>
+        /// <remarks>
+        /// Deliberately independent of <see cref="MarkInheritedProperties"/>
+        /// rather than folded into its walk: that method's per-class loop
+        /// starts with <c>if (!HasAnyProperties(template)) continue;</c>,
+        /// which would skip the Rules-ancestor check for any class that
+        /// declares Rules but no Properties. Keeping the walk separate — at
+        /// the cost of rebuilding the byId/byName lookup tables — avoids
+        /// that guard clause entirely so every ClassModel with a parent gets
+        /// checked regardless of its own property count.
+        /// </remarks>
+        private static void MarkParentHasRules(
+            List<ITemplateModel> templates,
+            IEnumerable<MTConnectClassModel> importClassModels)
+        {
+            if (templates == null) return;
+
+            var classTemplates = templates.OfType<MTConnectClassModel>().ToList();
+            if (classTemplates.Count == 0) return;
+
+            var byId = new Dictionary<string, MTConnectClassModel>(StringComparer.Ordinal);
+            var byName = new Dictionary<string, MTConnectClassModel>(StringComparer.Ordinal);
+            foreach (var ct in classTemplates)
+            {
+                if (!string.IsNullOrEmpty(ct.Id)) byId.TryAdd(ct.Id, ct);
+                if (!string.IsNullOrEmpty(ct.Name)) byName.TryAdd(ct.Name, ct);
+            }
+            if (importClassModels != null)
+            {
+                foreach (var cm in importClassModels)
+                {
+                    if (cm == null) continue;
+                    if (!string.IsNullOrEmpty(cm.Id)) byId.TryAdd(cm.Id, cm);
+                    if (!string.IsNullOrEmpty(cm.Name)) byName.TryAdd(cm.Name, cm);
+                }
+            }
+
+            foreach (var template in classTemplates)
+            {
+                if (template is not ClassModel classModel) continue;
+                if (string.IsNullOrEmpty(template.ParentName)) continue;
+
+                var visited = new HashSet<string>(StringComparer.Ordinal);
+                var currentId = template.Id;
+                var parentName = template.ParentName;
+                var parentHasRules = false;
+
+                while (!string.IsNullOrEmpty(parentName))
+                {
+                    var parent = ResolveParent(currentId, parentName, byId, byName);
+                    if (parent == null) break;
+                    if (!visited.Add(parent.Id ?? parentName)) break;
+                    if (parent.Rules != null && parent.Rules.Length > 0)
+                    {
+                        parentHasRules = true;
+                        break;
+                    }
+                    currentId = parent.Id;
+                    parentName = parent.ParentName;
+                }
+
+                classModel.ParentHasRules = parentHasRules;
+            }
+        }
+
         /// <summary>
         /// Resolves a parent ClassModel from <paramref name="parentName"/>
         /// (a bare <c>ClassName</c> as stored in

build/MTConnect.NET-SysML-Import/CSharp/Templates/EnumDescriptions.scriban → build/MTConnect.NET-SysML-Import/CSharp/Templates/EnumOrStringDescriptions.scriban

@@ -1,10 +1,15 @@
 // Copyright (c) 2024 TrakHound Inc., All Rights Reserved.
 // TrakHound Inc. licenses this file to you under the MIT license.
+{{-# Shape-B consolidated Descriptions template. Valid for every MTConnect version. #}}
+{{-# Covers both the enum-descriptions and the string-constant-descriptions callers. #}}
+{{-# When is_string is truthy, the Get(...) overload takes a `string value` and the #}}
+{{-# class doc reads "string constant" instead of "value"; when falsy, the Get(...) #}}
+{{-# overload takes an enum-typed value and the class doc reads "value". #}}
 
 namespace {{namespace}}
 {
     /// <summary>
-    /// Description text for each <see cref="{{name}}"/> value as defined by the MTConnect Standard.
+    /// Description text for each <see cref="{{name}}"/> {{ if is_string }}string constant{{ else }}value{{ end }} as defined by the MTConnect Standard.
     /// </summary>
     public static class {{name}}Descriptions
     {
@@ -21,9 +26,9 @@ namespace {{namespace}}
 
 
         /// <summary>
-        /// Returns the MTConnect Standard description text for the specified <see cref="{{name}}"/> value, or <c>null</c> when none is defined.
+        /// Returns the MTConnect Standard description text for the specified{{ if is_string }}{{ else }} <see cref="{{name}}"/>{{ end }} value, or <c>null</c> when none is defined.
         /// </summary>
-        public static string Get({{name}} value)
+        public static string Get({{ if is_string }}string{{ else }}{{name}}{{ end }} value)
         {
             switch (value)
             {

build/MTConnect.NET-SysML-Import/CSharp/Templates/Model.scriban

@@ -24,7 +24,7 @@ namespace {{namespace}}
         /// SysML model, preserved verbatim so downstream consumers can
         /// inspect the spec's raw validation rules at runtime.
         /// </summary>
-        public {{ if (parent_name) }}new {{ end }}static readonly string[] Rules = new[]
+        public {{ if (parent_has_rules) }}new {{ end }}static readonly string[] Rules = new[]
         {
 {{- for rule in rules }}{{ if (!for.last) }}
             "{{ rule | string.replace `\` `\\` | string.replace `"` `\"` | string.replace "\r" "\\r" | string.replace "\n" "\\n" | string.replace "\t" "\\t" }}",

build/MTConnect.NET-SysML-Import/CSharp/Templates/Pallets.MeasurementInterface.scriban

@@ -0,0 +1,12 @@
+// Copyright (c) 2025 TrakHound Inc., All Rights Reserved.
+// TrakHound Inc. licenses this file to you under the MIT license.
+
+namespace {{namespace}}
+{
+    /// <summary>
+    /// {{description}}
+    /// </summary>
+    public interface I{{name}} : IMeasurement
+    {
+    }
+}