DrakiaXYZ/AssemblyTool
0
0
Fork 0
Code Pull Requests Activity

Current progress

Browse Source
This commit is contained in:
Cj 2024-06-11 23:07:59 -04:00
parent f76ba2f091
commit dfd50b3b75
6 changed files with 146 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
AssemblyRemapper/Models/AppSettingsModel.cs
View File

@ -27,7 +27,7 @@ internal class Remap
public string OldTypeName { get; set; } = string.Empty;
public bool UseDirectRename { get; set; }
public bool UseForceRename { get; set; }
public RemapSearchParams SearchParams { get; set; } = new();
}
@ -46,8 +46,7 @@ internal class RemapSearchParams
public bool? IsSealed { get; set; } = null;
public bool? HasAttribute { get; set; } = null;
public bool? IsDerived { get; set; } = null;
public string? BaseClassName { get; set; } = null;
public bool? IsGeneric { get; set; } = null;
public bool? HasGenericParameters { get; set; } = null;
public HashSet<string> MethodNamesToMatch { get; set; } = [];
public HashSet<string> MethodNamesToIgnore { get; set; } = [];

15
AssemblyRemapper/Models/ScoringModel.cs
View File

@ -1,4 +1,4 @@
using AssemblyRemapper.Reflection;
using AssemblyRemapper.Utils;
using Mono.Cecil;
namespace AssemblyRemapper.Models;
@ -22,8 +22,17 @@ internal static class ScoringModelExtensions
{
try
{
if (Remapper.ScoringModels.TryGetValue(model.ProposedNewName, out HashSet<ScoringModel> modelHashset))
if (DataProvider.ScoringModels.TryGetValue(model.ProposedNewName, out HashSet<ScoringModel> modelHashset))
{
foreach (var outVal in modelHashset)
{
if (outVal.Definition.FullName == model.Definition.FullName)
{
Logger.Log("Skipping adding duplicate type match to list", ConsoleColor.Yellow);
return;
}
}
modelHashset.Add(model);
return;
}
@ -33,7 +42,7 @@ internal static class ScoringModelExtensions
model
};
Remapper.ScoringModels.Add(model.ProposedNewName, newHash);
DataProvider.ScoringModels.Add(model.ProposedNewName, newHash);
}
catch (Exception e)
{

157
AssemblyRemapper/Reflection/Remapper.cs
View File

@ -6,31 +6,27 @@ namespace AssemblyRemapper.Reflection;
internal class Remapper
{
public static Dictionary<string, HashSet<ScoringModel>> ScoringModels { get; set; } = [];
public void InitializeRemap()
{
// Make sure any previous results are cleared just incase
ScoringModels.Clear();
DisplayBasicModuleInformation();
StartRemap();
}
private void DisplayBasicModuleInformation()
{
Logger.Log($"Module contains {DataProvider.ModuleDefinition.Types.Count} Types");
Logger.Log($"Starting remap...");
Logger.Log($"Publicize: {DataProvider.AppSettings.Publicize}");
Logger.Log($"Unseal: {DataProvider.AppSettings.Unseal}");
Logger.Log("-----------------------------------------------", ConsoleColor.Yellow);
Logger.Log($"Starting remap...", ConsoleColor.Yellow);
Logger.Log($"Module contains {DataProvider.ModuleDefinition.Types.Count} Types", ConsoleColor.Yellow);
Logger.Log($"Publicize: {DataProvider.AppSettings.Publicize}", ConsoleColor.Yellow);
Logger.Log($"Unseal: {DataProvider.AppSettings.Unseal}", ConsoleColor.Yellow);
Logger.Log("-----------------------------------------------", ConsoleColor.Yellow);
}
private void StartRemap()
{
foreach (var remap in DataProvider.AppSettings.Remaps)
{
Logger.Log("-----------------------------------------------");
Logger.Log($"Trying to remap {remap.NewTypeName}...");
Logger.Log($"Trying to remap {remap.NewTypeName}...", ConsoleColor.Gray);
HandleMapping(remap);
}
@ -49,20 +45,8 @@ internal class Remapper
private void HandleMapping(Remap mapping)
{
string newName = mapping.NewTypeName;
string oldName = mapping?.OldTypeName ?? string.Empty;
bool useDirectRename = mapping.UseDirectRename;
foreach (var type in DataProvider.ModuleDefinition.Types)
{
// Handle Direct Remaps by strict naming first bypasses everything else
if (useDirectRename)
{
HandleByDirectName(oldName, newName, type);
continue;
}
ScoreType(type, mapping);
}
}
@ -71,7 +55,7 @@ internal class Remapper
{
if (!DataProvider.AppSettings.Publicize) { return; }
Logger.Log("Starting publicization...");
Logger.Log("Starting publicization...", ConsoleColor.Green);
foreach (var type in DataProvider.ModuleDefinition.Types)
{
@ -109,7 +93,7 @@ internal class Remapper
{
if (!DataProvider.AppSettings.Unseal) { return; }
Logger.Log("Starting unseal...");
Logger.Log("Starting unseal...", ConsoleColor.Green);
foreach (var type in DataProvider.ModuleDefinition.Types)
{
@ -117,23 +101,15 @@ internal class Remapper
}
}
private void HandleByDirectName(string oldName, string newName, TypeDefinition type)
{
if (type.Name != oldName) { return; }
Logger.Log($"Renaming directly...");
type.Name = newName;
RenameService.RenameAllFields(oldName, newName, DataProvider.ModuleDefinition.Types);
RenameService.RenameAllProperties(oldName, newName, DataProvider.ModuleDefinition.Types);
Logger.Log($"Renamed {oldName} to {newName}");
Logger.Log("-----------------------------------------------");
}
private void ScoreType(TypeDefinition type, Remap remap, string parentTypeName = "")
{
// Handle Direct Remaps by strict naming first bypasses everything else
if (remap.UseForceRename)
{
HandleByDirectName(type, remap);
return;
}
foreach (var nestedType in type.NestedTypes)
{
ScoreType(nestedType, remap, type.Name);
@ -147,33 +123,38 @@ internal class Remapper
if (type.MatchIsAbstract(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("IsAbstract", type.Name, score.ProposedNewName);
return;
}
/*
if (type.MatchIsEnum(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("IsEnum", type.Name, score.ProposedNewName);
return;
}
if (type.MatchIsNested(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("IsNested", type.Name, score.ProposedNewName);
return;
}
type.MatchIsSealed(remap.SearchParams, score);
if (type.MatchIsSealed(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("IsSealed", type.Name, score.ProposedNewName);
return;
}
*/
if (type.MatchIsDerived(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("IsDerived", type.Name, score.ProposedNewName);
return;
}
if (type.MatchIsInterface(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("IsInterface", type.Name, score.ProposedNewName);
return;
}
@ -184,105 +165,107 @@ internal class Remapper
if (type.MatchIsPublic(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("IsPublic", type.Name, score.ProposedNewName);
return;
}
if (type.MatchHasAttribute(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("HasAttribute", type.Name, score.ProposedNewName);
return;
}
if (type.MatchMethods(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("Methods", type.Name, score.ProposedNewName);
return;
}
if (type.MatchFields(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("Fields", type.Name, score.ProposedNewName);
return;
}
if (type.MatchProperties(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("Properties", type.Name, score.ProposedNewName);
return;
}
if (type.MatchNestedTypes(remap.SearchParams, score) == EMatchResult.NoMatch)
{
LogDiscard("NestedTypes", type.Name, score.ProposedNewName);
return;
}
*/
ScoringModelExtensions.AddModelToResult(score);
}
private void HandleByDirectName(TypeDefinition type, Remap remap)
{
if (type.Name != remap.OldTypeName) { return; }
var oldName = type.Name;
type.Name = remap.NewTypeName;
RenameService.RenameAllFields(remap, DataProvider.ModuleDefinition.Types);
RenameService.RenameAllProperties(remap, DataProvider.ModuleDefinition.Types);
Logger.Log($"Renamed {oldName} to {type.Name} directly", ConsoleColor.Green);
}
private void LogDiscard(string action, string type, string search)
{
if (DataProvider.AppSettings.Debug)
{
Logger.Log($"[{action}] Discarding type [{type}] for search [{search}]", ConsoleColor.Red);
}
}
private void ChooseBestMatches()
{
foreach (var remap in ScoringModels)
foreach (var score in DataProvider.ScoringModels)
{
ChooseBestMatch(remap.Value, true);
ChooseBestMatch(score.Value, true);
}
}
private void ChooseBestMatch(HashSet<ScoringModel> scores, bool isBest = false)
{
if (ScoringModels.Count == 0)
if (DataProvider.ScoringModels.Count == 0)
{
return;
}
var highestScore = scores.OrderByDescending(model => model.Score).FirstOrDefault();
var secondScore = scores.OrderByDescending(model => model.Score).Skip(1).FirstOrDefault();
var nextHighestScores = scores.OrderByDescending(model => model.Score).Skip(1);
if (highestScore is null || secondScore is null) { return; }
if (highestScore is null) { return; }
var potentialText = isBest
? "Best potential"
: "Next potential";
if (highestScore.Score <= 0) { return; }
Logger.Log("-----------------------------------------------", ConsoleColor.Green);
Logger.Log($"Found {scores.Count} results from search", ConsoleColor.Green);
Logger.Log($"{potentialText} match is `{highestScore.Definition.Name}` for `{highestScore.ProposedNewName}`", ConsoleColor.Green);
Logger.Log("-----------------------------------------------");
Logger.Log($"Found {scores.Count} possible matches");
Logger.Log($"Scored: {highestScore.Score} points");
Logger.Log($"Next Best: {secondScore.Score} points");
Logger.Log($"{potentialText} match is `{highestScore.Definition.Name}` for `{highestScore.ProposedNewName}`");
foreach (var score in nextHighestScores)
{
Logger.Log($"Next potential match is `{score.Definition.Name}` for `{highestScore.ProposedNewName}`", ConsoleColor.Yellow);
}
if (DataProvider.AppSettings.ScoringMode)
{
Logger.Log("Show next result? (y/n)");
var answer = Console.ReadLine();
scores.Remove(highestScore);
ChooseBestMatch(scores);
if (answer == "yes" || answer == "y")
{
scores.Remove(highestScore);
ChooseBestMatch(scores);
}
Logger.Log("-----------------------------------------------");
Logger.Log("-----------------------------------------------", ConsoleColor.Green);
return;
}
var anwser = "";
if (!DataProvider.AppSettings.SilentMode)
{
Logger.Log($"Should we continue? (y/n)");
anwser = Console.ReadLine();
}
if (anwser == "yes" || anwser == "y" || DataProvider.AppSettings.SilentMode)
{
var oldName = highestScore.Definition.Name;
highestScore.Definition.Name = highestScore.ProposedNewName;
RenameService.RenameAllFields(oldName, highestScore.Definition.Name, DataProvider.ModuleDefinition.Types);
RenameService.RenameAllProperties(oldName, highestScore.Definition.Name, DataProvider.ModuleDefinition.Types);
Logger.Log($"Remapped {oldName} to `{highestScore.Definition.Name}`");
Logger.Log("-----------------------------------------------");
return;
}
Logger.Log("-----------------------------------------------", ConsoleColor.Green);
scores.Remove(highestScore);
ChooseBestMatch(scores);
@ -299,8 +282,8 @@ internal class Remapper
DataProvider.AssemblyDefinition.Write(remappedPath);
Logger.Log("-----------------------------------------------");
Logger.Log($"Complete: Assembly written to `{remappedPath}`");
Logger.Log("-----------------------------------------------");
Logger.Log("-----------------------------------------------", ConsoleColor.Green);
Logger.Log($"Complete: Assembly written to `{remappedPath}`", ConsoleColor.Green);
Logger.Log("-----------------------------------------------", ConsoleColor.Green);
}
}

30
AssemblyRemapper/Reflection/RenameService.cs
View File

@ -1,4 +1,6 @@
using AssemblyRemapper.Utils;
using AssemblyRemapper.Models;
using AssemblyRemapper.Utils;
using Mono.Cecil;
using Mono.Collections.Generic;
namespace AssemblyRemapper.Reflection;
@ -6,20 +8,19 @@ namespace AssemblyRemapper.Reflection;
internal static class RenameService
{
public static void RenameAllFields(
string oldName,
string newName,
Collection<Mono.Cecil.TypeDefinition> types)
Remap remap,
Collection<TypeDefinition> typesToCheck)
{
foreach (var type in types)
foreach (var type in typesToCheck)
{
int fieldCount = 0;
foreach (var field in type.Fields)
{
if (field.FieldType.ToString() == newName)
if (field.FieldType.ToString() == remap.NewTypeName)
{
Logger.Log($"Renaming Field: `{field.Name}` on Type `{type}`");
field.Name = GetNewFieldName(newName, field.IsPrivate, fieldCount);
field.Name = GetNewFieldName(remap.NewTypeName, field.IsPrivate, fieldCount);
fieldCount++;
}
}
@ -28,27 +29,26 @@ internal static class RenameService
{
foreach (var _ in type.NestedTypes)
{
RenameAllFields(oldName, newName, type.NestedTypes);
RenameAllFields(remap, type.NestedTypes);
}
}
}
}
public static void RenameAllProperties(
string oldName,
string newName,
Collection<Mono.Cecil.TypeDefinition> types)
Remap remap,
Collection<TypeDefinition> typesToCheck)
{
foreach (var type in types)
foreach (var type in typesToCheck)
{
int propertyCount = 0;
foreach (var property in type.Properties)
{
if (property.PropertyType.ToString() == newName)
if (property.PropertyType.ToString() == remap.NewTypeName)
{
Logger.Log($"Renaming Property: `{property.Name}` on Type `{type}`");
property.Name = propertyCount > 0 ? $"{newName}_{propertyCount}" : newName;
property.Name = propertyCount > 0 ? $"{remap.NewTypeName}_{propertyCount}" : remap.NewTypeName;
}
}
@ -56,7 +56,7 @@ internal static class RenameService
{
foreach (var _ in type.NestedTypes)
{
RenameAllProperties(oldName, newName, type.NestedTypes);
RenameAllProperties(remap, type.NestedTypes);
}
}
}

116
AssemblyRemapper/Reflection/SearchProvider.cs
View File

@ -1,5 +1,4 @@
using AssemblyRemapper.Models;
using AssemblyRemapper.Utils;
using Mono.Cecil;
using Mono.Cecil.Rocks;
@ -19,18 +18,15 @@ internal static class SearchProvider
// Interfaces cannot be abstract, and abstract cannot be static
if (type.IsInterface || type.GetStaticConstructor() != null)
{
Logger.Log($"Searching for an abstract type, skipping interface or static");
return EMatchResult.NoMatch;
}
if (type.IsAbstract != parms.IsAbstract)
if (type.IsAbstract == parms.IsAbstract)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : IsAbstract");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` IsAbstract does not match.");
return EMatchResult.NoMatch;
}
@ -44,11 +40,9 @@ internal static class SearchProvider
if (type.IsEnum == parms.IsEnum)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : IsEnum");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` IsEnum does not match.");
return EMatchResult.NoMatch;
}
@ -62,11 +56,9 @@ internal static class SearchProvider
if (type.IsNested == parms.IsNested)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : IsNested");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` IsNested does not match.");
return EMatchResult.NoMatch;
}
@ -80,11 +72,9 @@ internal static class SearchProvider
if (type.IsSealed == parms.IsSealed)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : IsSealed");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` IsSealed does not match.");
return EMatchResult.NoMatch;
}
@ -98,11 +88,9 @@ internal static class SearchProvider
if (type.BaseType != null && (bool)parms.IsDerived)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : IsDerived");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` IsDerived does not match.");
return EMatchResult.NoMatch;
}
@ -113,38 +101,28 @@ internal static class SearchProvider
return EMatchResult.Disabled;
}
// Interfaces cannot be a class
if (type.IsClass)
{
return EMatchResult.NoMatch;
}
if (type.IsInterface != parms.IsInterface)
if (type.IsInterface == parms.IsInterface)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : IsInterface");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` IsInterface does not match.");
return EMatchResult.NoMatch;
}
public static EMatchResult MatchIsGeneric(this TypeDefinition type, RemapSearchParams parms, ScoringModel score)
{
if (parms.IsGeneric is null)
if (parms.HasGenericParameters is null)
{
return EMatchResult.Disabled;
}
if (type.HasGenericParameters == parms.IsGeneric)
if (type.HasGenericParameters == parms.HasGenericParameters)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : IsGeneric");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` IsGeneric does not match.");
return EMatchResult.NoMatch;
}
@ -155,14 +133,14 @@ internal static class SearchProvider
return EMatchResult.Disabled;
}
if (type.IsPublic == parms.IsPublic)
var boolToCheck = parms.IsPublic == true ? type.IsPublic : type.IsNotPublic;
if (boolToCheck == !parms.IsPublic)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : IsPublic");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` IsPublic does not match.");
return EMatchResult.NoMatch;
}
@ -176,30 +154,26 @@ internal static class SearchProvider
if (type.HasCustomAttributes == parms.HasAttribute)
{
score.Score += 1;
Logger.Log($"Matched `{type.Name}` on search `{score.ProposedNewName}` : HasAttribute");
return EMatchResult.Match;
}
Logger.Log($"Skipping `{type.Name}` on search `{score.ProposedNewName}` HasAttribute does not match.");
return EMatchResult.NoMatch;
}
public static EMatchResult MatchMethods(this TypeDefinition type, RemapSearchParams parms, ScoringModel score)
{
// Ignore types that dont have methods when we are looking for them, and ignore types that
// have methods while we're not looking for them
if ((type.HasMethods is true && parms.MethodNamesToMatch.Count == 0) || (type.HasMethods is false && parms.MethodNamesToMatch.Count > 0))
if (parms.MethodNamesToMatch.Count == 0) { return EMatchResult.Disabled; }
if (type.HasMethods)
{
return EMatchResult.NoMatch;
// `*` is the wildcard to ignore all methods that exist on types
if (parms.MethodNamesToIgnore.Contains("*"))
{
return EMatchResult.NoMatch;
}
}
// `*` is the wildcard to ignore all methods that exist on types
if (parms.MethodNamesToIgnore.Contains("*"))
{
return EMatchResult.NoMatch;
}
int matchCount = 0;
var matchCount = 0;
foreach (var method in type.Methods)
{
@ -209,10 +183,14 @@ internal static class SearchProvider
return EMatchResult.NoMatch;
}
if (parms.MethodNamesToMatch.Contains(method.Name))
foreach (var name in parms.MethodNamesToMatch)
{
matchCount++;
score.Score += 2;
if (method.Name == name)
{
matchCount += 1;
score.Score += 2;
continue;
}
}
}
@ -221,17 +199,15 @@ internal static class SearchProvider
public static EMatchResult MatchFields(this TypeDefinition type, RemapSearchParams parms, ScoringModel score)
{
// Ignore types that dont have fields when we are looking for them, and ignore types that
// have fields while we're not looking for them
if ((type.HasFields is true && parms.FieldNamesToMatch.Count == 0) || (type.HasFields is false && parms.FieldNamesToMatch.Count > 0))
{
return EMatchResult.NoMatch;
}
if (parms.FieldNamesToMatch.Count == 0) { return EMatchResult.Disabled; }
// `*` is the wildcard to ignore all fields that exist on types
if (parms.FieldNamesToIgnore.Contains("*"))
if (type.HasFields)
{
return EMatchResult.NoMatch;
// `*` is the wildcard to ignore all fields that exist on types
if (parms.FieldNamesToIgnore.Contains("*"))
{
return EMatchResult.NoMatch;
}
}
int matchCount = 0;
@ -256,17 +232,15 @@ internal static class SearchProvider
public static EMatchResult MatchProperties(this TypeDefinition type, RemapSearchParams parms, ScoringModel score)
{
// Ignore types that dont have properties when we are looking for them, and ignore types
// that have properties while we're not looking for them
if ((type.HasProperties is true && parms.PropertyNamesToMatch.Count == 0) || (type.HasProperties is false && parms.PropertyNamesToMatch.Count > 0))
{
return EMatchResult.NoMatch;
}
if (parms.PropertyNamesToMatch.Count == 0) { return EMatchResult.Disabled; }
// `*` is the wildcard to ignore all properties that exist on types
if (parms.PropertyNamesToIgnore.Contains("*"))
if (type.HasProperties)
{
return EMatchResult.NoMatch;
// `*` is the wildcard to ignore all fields that exist on types
if (parms.PropertyNamesToIgnore.Contains("*"))
{
return EMatchResult.NoMatch;
}
}
int matchCount = 0;
@ -291,17 +265,15 @@ internal static class SearchProvider
public static EMatchResult MatchNestedTypes(this TypeDefinition type, RemapSearchParams parms, ScoringModel score)
{
// Ignore types that dont have nested types when we are looking for them, and ignore types
// that have nested types while we're not looking for them
if ((type.HasNestedTypes is true && parms.NestedTypesToMatch.Count == 0) || (type.HasNestedTypes is false && parms.NestedTypesToMatch.Count > 0))
{
return EMatchResult.NoMatch;
}
if (parms.NestedTypesToMatch.Count == 0) { return EMatchResult.Disabled; }
// `*` is the wildcard to ignore all nested types that exist on types
if (parms.PropertyNamesToIgnore.Contains("*"))
if (type.HasNestedTypes)
{
return EMatchResult.NoMatch;
// `*` is the wildcard to ignore all fields that exist on types
if (parms.NestedTypesToIgnore.Contains("*"))
{
return EMatchResult.NoMatch;
}
}
int matchCount = 0;

3
AssemblyRemapper/Utils/DataProvider.cs
View File

@ -12,6 +12,8 @@ internal static class DataProvider
LoadAssemblyDefinition();
}
public static Dictionary<string, HashSet<ScoringModel>> ScoringModels { get; set; } = [];
public static AppSettings AppSettings { get; private set; }
public static AssemblyDefinition AssemblyDefinition { get; private set; }
@ -57,6 +59,7 @@ internal static class DataProvider
if (module.Name == fileName)
{
ModuleDefinition = module;
return;
}
}