Lexical rules code gen

Author: antoineatstariongroup

SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreLexicalRulesGeneratorTestFixture.cs

@@ -0,0 +1,63 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UmlCoreLexicalRulesGeneratorTestFixture.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.CodeGenerator.Tests.Generators.UmlHandleBarsGenerators
+{
+    using System.IO;
+    using System.Threading.Tasks;
+
+    using NUnit.Framework;
+
+    using SysML2.NET.CodeGenerator.Generators.UmlHandleBarsGenerators;
+    using SysML2.NET.CodeGenerator.Grammar;
+    using SysML2.NET.CodeGenerator.Grammar.Model;
+
+    [TestFixture]
+    public class UmlCoreLexicalRulesGeneratorTestFixture
+    {
+        private DirectoryInfo outputDirectoryInfo;
+        private UmlCoreLexicalRulesGenerator generator;
+        private TextualNotationSpecification textualNotationSpecification;
+
+        [OneTimeSetUp]
+        public void OneTimeSetup()
+        {
+            var directoryInfo = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+
+            var path = Path.Combine("UML", "_SysML2.NET.Core.UmlCoreLexicalRulesGenerator");
+
+            this.outputDirectoryInfo = directoryInfo.CreateSubdirectory(path);
+            this.generator = new UmlCoreLexicalRulesGenerator();
+
+            var textualRulesFolder = Path.Combine(TestContext.CurrentContext.TestDirectory, "datamodel");
+
+            // The lexical support classes (Keywords, SymbolicKeywordKind, SymbolicKeywordKindExtensions)
+            // are built from the SysML grammar only — the KerML grammar is intentionally excluded so
+            // the emitted set of tokens matches the SysML v2 specification surface.
+            this.textualNotationSpecification = GrammarLoader.LoadTextualNotationSpecification(Path.Combine(textualRulesFolder, "SysML-textual-bnf.kebnf"));
+        }
+
+        [Test]
+        public async Task VerifyCanGenerateLexicalRules()
+        {
+            await Assert.ThatAsync(() => this.generator.GenerateAsync(GeneratorSetupFixture.XmiReaderResult, this.textualNotationSpecification, this.outputDirectoryInfo), Throws.Nothing);
+        }
+    }
+}

SysML2.NET.CodeGenerator/Extensions/PropertyExtension.cs

@@ -72,7 +72,7 @@ public static string QueryPropertyNameBasedOnUmlProperties(this IProperty proper
         {
             ArgumentNullException.ThrowIfNull(property);
 
-            return property.IsDerived || property.IsDerivedUnion ? StringExtensions.LowerCaseFirstLetter(property.Name) : StringExtensions.CapitalizeFirstLetter(property.Name);
+            return property.IsDerived || property.IsDerivedUnion ? property.Name.LowerCaseFirstLetter() : property.Name.CapitalizeFirstLetter();
         }
 
         /// <summary>

SysML2.NET.CodeGenerator/Extensions/StringExtensions.cs

@@ -0,0 +1,120 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StringExtensions.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.CodeGenerator.Extensions
+{
+    using System.Text;
+
+    /// <summary>
+    /// String helpers used by the grammar and lexical-rules code-generation passes.
+    /// </summary>
+    public static class StringExtensions
+    {
+        /// <summary>
+        /// Tests whether a string follows the SysML lexical-rule naming convention: uppercase
+        /// letters, digits and underscores only, with at least one letter (e.g.
+        /// <c>RESERVED_KEYWORD</c>, <c>DEFINED_BY</c>, <c>STRING_VALUE</c>).
+        /// </summary>
+        /// <param name="value">The string to test</param>
+        /// <returns><c>true</c> when the string matches the all-uppercase snake-case convention</returns>
+        public static bool IsAllUpperSnake(this string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return false;
+            }
+
+            var hasLetter = false;
+
+            foreach (var character in value)
+            {
+                if (char.IsLetter(character))
+                {
+                    hasLetter = true;
+
+                    if (!char.IsUpper(character))
+                    {
+                        return false;
+                    }
+                }
+                else if (character != '_' && !char.IsDigit(character))
+                {
+                    return false;
+                }
+            }
+
+            return hasLetter;
+        }
+
+        /// <summary>
+        /// Tests whether the supplied string contains any letter.
+        /// </summary>
+        /// <param name="value">The string to test</param>
+        /// <returns><c>true</c> when at least one letter is present</returns>
+        public static bool ContainsAnyLetter(this string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return false;
+            }
+
+            foreach (var character in value)
+            {
+                if (char.IsLetter(character))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Converts a <c>SNAKE_CASE</c> identifier into <c>PascalCase</c>
+        /// (e.g. <c>DEFINED_BY</c> → <c>DefinedBy</c>).
+        /// </summary>
+        /// <param name="value">The snake-case identifier</param>
+        /// <returns>The PascalCase form</returns>
+        public static string ToPascalCaseFromSnake(this string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return value;
+            }
+
+            var builder = new StringBuilder(value.Length);
+            var capitalizeNext = true;
+
+            foreach (var character in value)
+            {
+                if (character == '_')
+                {
+                    capitalizeNext = true;
+                    continue;
+                }
+
+                builder.Append(capitalizeNext ? char.ToUpperInvariant(character) : char.ToLowerInvariant(character));
+                capitalizeNext = false;
+            }
+
+            return builder.ToString();
+        }
+    }
+}