Using MikaelDui.CodeAnalysis.CSharp.Extensions & added package retent…

…ion policy (#21) * Create github-package-retention.yml * Stop spamming NuGet.org * Keep spamming NuGet.org No where close to 350 packages/hour. * Now using MikaelDui.CodeAnalysis.CSharp.Extensions * Update github-package-retention.yml
mikaeldui · Jan 11, 2022 · 337cd62 · 337cd62
1 parent 8738798
commit 337cd62
Show file tree

Hide file tree

Showing 4 changed files with 32 additions and 89 deletions.
diff --git a/.github/workflows/github-package-retention.yml b/.github/workflows/github-package-retention.yml
@@ -0,0 +1,9 @@
+name: GitHub Packages Retention
+on:
+  schedule:
+    # * is a special character in YAML so you have to quote this string
+    - cron:  '30 5,17 * * *'
+jobs:
+  retention:
+    name: "Package Retention"
+    uses: mikaeldui/actions/.github/workflows/github-packages-retention.yml@main
diff --git a/RiotGames.Client.CodeGeneration/CodeAnalysisHelpers.cs b/RiotGames.Client.CodeGeneration/CodeAnalysisHelpers.cs
@@ -20,13 +20,13 @@ internal static class CodeAnalysisHelper
             SF.NamespaceDeclaration(ParseName(string.Join('.', @namespace))).NormalizeWhitespace();
 
         public static ClassDeclarationSyntax PublicClassDeclaration(string identifier) =>
-            ClassDeclaration(identifier).AddModifiers(Token(SyntaxKind.PublicKeyword));
+            ClassDeclaration(identifier).WithModifier(SyntaxKind.PublicKeyword);
 
         public static ClassDeclarationSyntax PublicPartialClassDeclaration(string identifier) =>
-            ClassDeclaration(identifier).AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.PartialKeyword));
+            ClassDeclaration(identifier).WithModifiers(SyntaxKind.PublicKeyword, SyntaxKind.PartialKeyword);
 
         public static ClassDeclarationSyntax PublicClassDeclarationWithBaseType(string identifier, string baseTypeName) =>
-            PublicClassDeclaration(identifier).AddBaseType(baseTypeName);
+            PublicClassDeclaration(identifier).WithBaseType(baseTypeName);
 
         public static ConstructorDeclarationSyntax ConstructorDeclaration(string identifier, string parameterType, string parameterIdentifier) =>
             SF.ConstructorDeclaration(identifier).WithParameter(parameterType, parameterIdentifier);
@@ -36,12 +36,11 @@ internal static class CodeAnalysisHelper
 
         public static ConstructorDeclarationSyntax InternalConstructorDeclaration(string identifier, string parameterType, string parameterIdentifier, string fieldIdentifier, string? parameterProperty = null) =>
             ConstructorDeclaration(identifier, parameterType, parameterIdentifier)
-                .WithBody($"{fieldIdentifier} = {parameterIdentifier + (parameterProperty == null ? null : '.' + parameterProperty)};")
-                .AddModifiers(Token(SyntaxKind.InternalKeyword));
+                .WithModifier(SyntaxKind.InternalKeyword)
+                .WithBody($"{fieldIdentifier} = {parameterIdentifier + (parameterProperty == null ? null : '.' + parameterProperty)};");
 
         public static EnumDeclarationSyntax PublicEnumDeclaration(string identifier, params string[] members) =>
-            EnumDeclaration(Identifier(identifier))
-                .AddModifiers(Token(SyntaxKind.PublicKeyword))
+            EnumDeclaration(Identifier(identifier)).WithModifiers(SyntaxKind.PublicKeyword.ToTokenList())
                 .AddMembers(members.Select(m => EnumMemberDeclaration(Identifier(m))).ToArray());
 
         public static AttributeSyntax Attribute(string identifier) =>
@@ -58,42 +57,37 @@ internal static class CodeAnalysisHelper
                 ));
 
         public static FieldDeclarationSyntax PrivateFieldDeclaration(string typeName, string identifier) =>
-            FieldDeclaration(typeName, identifier.StartWith("_")).AddModifier(SyntaxKind.PrivateKeyword);
+            FieldDeclaration(typeName, identifier.StartWith("_")).WithModifier(SyntaxKind.PrivateKeyword);
 
         public static FieldDeclarationSyntax PrivateReadOnlyFieldDeclaration(string typeName, string identifier) =>
             PrivateFieldDeclaration(typeName, identifier).AddModifier(SyntaxKind.ReadOnlyKeyword);
 
         public static FieldDeclarationSyntax InternalFieldDeclaration(string typeName, string identifier) =>
-            FieldDeclaration(typeName, identifier).AddModifier(SyntaxKind.InternalKeyword);
+            FieldDeclaration(typeName, identifier).WithModifier(SyntaxKind.InternalKeyword);
 
         public static FieldDeclarationSyntax InternalReadOnlyFieldDeclaration(string typeName, string identifier) =>
             InternalFieldDeclaration(typeName, identifier).AddModifier(SyntaxKind.ReadOnlyKeyword);
 
         public static PropertyDeclarationSyntax PublicPropertyDeclaration(string typeName, string identifier) =>
             PropertyDeclaration(ParseTypeName(typeName), identifier)
-                .AddModifiers(Token(SyntaxKind.PublicKeyword))
+                .WithModifier(SyntaxKind.PublicKeyword)
                 .AddAccessorListAccessors(
                     AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(Token(SyntaxKind.SemicolonToken)),
                     AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
 
         public static PropertyDeclarationSyntax FieldBackedPublicReadOnlyPropertyDeclaration(string typeName, string identifier, string fieldIdentifier, string? typeConstructorArgument = null) =>
             PropertyDeclaration(ParseTypeName(typeName), Identifier(identifier))
-                .AddModifiers(Token(SyntaxKind.PublicKeyword))
-                .AddAccessorListAccessors(
-                    AccessorDeclaration(
-                        SyntaxKind.GetAccessorDeclaration,
-                        Block(ParseStatement($"if ({fieldIdentifier} == null)\n{fieldIdentifier} = new {typeName}({typeConstructorArgument});\n\nreturn {fieldIdentifier};"))));
+                .WithModifier(SyntaxKind.PublicKeyword)
+                .WithAccessor(SyntaxKind.GetAccessorDeclaration, $"if ({fieldIdentifier} == null)\n{fieldIdentifier} = new {typeName}({typeConstructorArgument});\n\nreturn {fieldIdentifier};");
 
         public static MethodDeclarationSyntax PublicAsyncTaskDeclaration(string returnType, string methodName, StatementSyntax bodyStatement, Dictionary<string, string>? parameters = null)
         {
-            var methodDeclaration = MethodDeclaration(
-                ParseTypeName("Task" + TypeArgumentStatement(returnType)), 
-                methodName.EndWith("Async"))
-                .AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.AsyncKeyword))
-                .WithBody(Block(bodyStatement));
+            var methodDeclaration = MethodDeclaration(ParseTypeName("Task" + TypeArgumentStatement(returnType)), methodName.EndWith("Async"))
+                .WithModifiers(SyntaxKind.PublicKeyword, SyntaxKind.AsyncKeyword)
+                .WithBody(bodyStatement.ToBlock());
 
             if (parameters != null)
-                methodDeclaration = methodDeclaration.AddParameterListParameters(parameters.ToParameters());
+                methodDeclaration = methodDeclaration.AddParameterListParameters(parameters.ToParameters().ToArray());
 
             return methodDeclaration;
         }

diff --git a/RiotGames.Client.CodeGeneration/Extensions/CodeAnalysisExtensions.cs b/RiotGames.Client.CodeGeneration/Extensions/CodeAnalysisExtensions.cs
@@ -7,89 +7,28 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
-using static RiotGames.Client.CodeGeneration.CodeAnalysisHelper;
-
 
 namespace RiotGames.Client.CodeGeneration
 {
-    using SF = SyntaxFactory;
+    using static SyntaxFactory;
+    using static CodeAnalysisHelper;
+
     [DebuggerStepThrough]
     internal static class CodeAnalysisExtensions
     {
-        #region Namespace
-
-        public static NamespaceDeclarationSyntax AddUsing(this NamespaceDeclarationSyntax @namespace, string usingNamespace) =>
-            @namespace.AddUsings(SF.UsingDirective(SF.ParseName(usingNamespace)));
-
         public static NamespaceDeclarationSyntax AddSystemTextJsonSerializationUsing(this NamespaceDeclarationSyntax @namespace) =>
             @namespace.AddUsing("System.Text.Json.Serialization");
 
         public static NamespaceDeclarationSyntax AddSystemDynamicUsing(this NamespaceDeclarationSyntax @namespace) =>
             @namespace.AddUsing("System.Dynamic");
 
-        #endregion Namespace
-
-        #region Class
-        public static ClassDeclarationSyntax AddPublicAsyncTask(this ClassDeclarationSyntax classDeclaration, string returnType, string methodIdentifier, StatementSyntax bodyStatement, Dictionary<string, string>? parameters = null) =>
-            classDeclaration.AddMembers(PublicAsyncTaskDeclaration(returnType, methodIdentifier, bodyStatement, parameters));
-
-        public static ClassDeclarationSyntax AddBaseType(this ClassDeclarationSyntax classDeclaration, string baseTypeName) =>
-            classDeclaration.AddBaseListTypes(SF.SimpleBaseType(SF.ParseTypeName(baseTypeName)));
-
-        #endregion Class
-
-        #region Constructor
-
-        public static ConstructorDeclarationSyntax WithParameter(this ConstructorDeclarationSyntax constructor, string parameterType, string parameterIdentifier) =>
-            constructor.AddParameterListParameters(Parameter(parameterType, parameterIdentifier));
-
-        public static ConstructorDeclarationSyntax WithBody(this ConstructorDeclarationSyntax constructor, string bodyStatement) =>
-            constructor.WithBody(SF.Block(SF.ParseStatement(bodyStatement)));
-
-        public static ConstructorDeclarationSyntax WithBaseConstructorInitializer(this ConstructorDeclarationSyntax constructor, params string[] argumentIdentifiers) =>
-            constructor.WithInitializer(SF.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer)
-                    .AddArgumentListArguments(argumentIdentifiers.Select(ai => SF.Argument(SF.IdentifierName(ai))).ToArray()));
-
-        public static ConstructorDeclarationSyntax WithModifier(this ConstructorDeclarationSyntax constructor, SyntaxKind modifier) =>
-            constructor.AddModifiers(Token(modifier));
-
-        #endregion Constructor
-
-        #region Enum
-
         public static EnumDeclarationSyntax AddJsonStringEnumAttribute(this EnumDeclarationSyntax @enum) =>
-            @enum.AddAttribute(Attribute("JsonStringEnum"));
-
-        #endregion Enum
-
-        #region Attribute
-
-        public static T AddAttribute<T>(this T member, AttributeSyntax attribute) where T : MemberDeclarationSyntax =>
-            (T)member.AddAttributeLists(SF.AttributeList(SF.SingletonSeparatedList<AttributeSyntax>(attribute)));
-
-        #endregion Attribute
-
-        #region Property
+            @enum.AddAttribute("JsonStringEnum");
 
         public static PropertyDeclarationSyntax AddJsonPropertyNameAttribute(this PropertyDeclarationSyntax property, string name) =>
-            property.AddAttribute(Attribute("JsonPropertyName", name));
-
-        #endregion Property
-
-        #region Field
-
-        public static FieldDeclarationSyntax AddModifier(this FieldDeclarationSyntax fieldDeclaration, SyntaxKind modifier) =>
-            fieldDeclaration.AddModifiers(SF.Token(modifier));
-
-        #endregion Field
-
-        #region Parameter
-
-        public static ParameterSyntax[] ToParameters(this IEnumerable<KeyValuePair<string, string>> parameters) =>
-            parameters.Select(p => Parameter(p.Value, p.Key)).ToArray();
-
-        #endregion Parameter
+            property.AddAttribute("JsonPropertyName", name);
 
+        public static ClassDeclarationSyntax AddPublicAsyncTask(this ClassDeclarationSyntax @class, string returnType, string methodIdentifier, StatementSyntax bodyStatement, Dictionary<string, string>? parameters = null) =>
+            @class.AddMembers(PublicAsyncTaskDeclaration(returnType, methodIdentifier, bodyStatement, parameters));
     }
 }
diff --git a/RiotGames.Client.CodeGeneration/RiotGames.Client.CodeGeneration.csproj b/RiotGames.Client.CodeGeneration/RiotGames.Client.CodeGeneration.csproj
@@ -12,6 +12,7 @@
     <PackageReference Include="Humanizer.Core" Version="*" />
     <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="*" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="*" />
+    <PackageReference Include="MikaelDui.CodeAnalysis.CSharp.Extensions" Version="*" />
     <PackageReference Include="MikaelDui.Extensions" Version="*" />
   </ItemGroup>