Implement excludeClassByName option (#6)

Author: josesimoes

source/MetadataProcessor.Console/Options.cs

@@ -33,6 +33,13 @@ public class Options
             HelpText = "Loads one (or more) assembly file(s) as a dependency(ies).")]
         public IEnumerable<string> LoadHints { get; set; }
 
+        [Option(
+            "excludeClassByName",
+            Required = false,
+            Default = null,
+            HelpText = "Removes the class from an assembly.")]
+        public IEnumerable<string> ExcludeClassByName { get; set; }
+
 
     }
 }

source/MetadataProcessor.Console/Program.cs

@@ -25,6 +25,8 @@ private sealed class MetadataProcessor
 
             private AssemblyDefinition _assemblyDefinition;
 
+            private List<string> _classNamesToExclude = new List<string>();
+
             public void Parse(string fileName)
             {
                 try
@@ -44,7 +46,7 @@ public void Compile(string fileName)
             {
                 try
                 {
-                    var builder = new nanoAssemblyBuilder(_assemblyDefinition);
+                    var builder = new nanoAssemblyBuilder(_assemblyDefinition, _classNamesToExclude);
 
                     using (var stream = File.Open(fileName, FileMode.Create, FileAccess.ReadWrite))
                     using (var writer = new BinaryWriter(stream))
@@ -76,6 +78,12 @@ public void AddLoadHint(
             {
                 _loadHints[assemblyName] = assemblyFileName;
             }
+
+            public void AddClassToExclude(
+                string className)
+            {
+                _classNamesToExclude.Add(className);
+            }
         }
 
         public static void Main(string[] args)
@@ -151,6 +159,15 @@ static void RunOptionsAndReturnExitCode(Options o)
                 while (hintCount < o.LoadHints.Count());
             }
 
+            // set class(es) to exclude
+            if (o.ExcludeClassByName.Any())
+            {
+                foreach (string name in o.ExcludeClassByName)
+                {
+                    md.AddClassToExclude(name);
+                }
+            }
+
             // parse assembly
             if (!string.IsNullOrEmpty(o.Parse))
             {

source/MetadataProcessor.Core/Tables/nanoFieldDefinitionTable.cs

@@ -84,6 +84,13 @@ public bool TryGetFieldReferenceId(
             bool trackMaxReferenceId,
             out ushort referenceId)
         {
+            // compare against classes to exclude
+            if (_context.ClassNamesToExclude.Contains(field.FullName))
+            {
+                referenceId = 0;
+                return false;
+            }
+
             var found = TryGetIdByValue(field, out referenceId);
             if (trackMaxReferenceId && found)
             {

source/MetadataProcessor.Core/Tables/nanoMethodDefinitionTable.cs

@@ -54,6 +54,13 @@ public bool TryGetMethodReferenceId(
             MethodDefinition methodDefinition,
             out ushort referenceId)
         {
+            // compare against classes to exclude
+            if (_context.ClassNamesToExclude.Contains(methodDefinition.FullName))
+            {
+                referenceId = 0;
+                return false;
+            }
+
             return TryGetIdByValue(methodDefinition, out referenceId);
         }
 

source/MetadataProcessor.Core/Tables/nanoTablesContext.cs

@@ -79,16 +79,30 @@ public sealed class nanoTablesContext
         public nanoTablesContext(
             AssemblyDefinition assemblyDefinition,
             List<string> explicitTypesOrder,
+            List<string> classNamesToExclude,
             ICustomStringSorter stringSorter,
             bool applyAttributesCompression)
         {
             AssemblyDefinition = assemblyDefinition;
 
+            ClassNamesToExclude = classNamesToExclude;
+
             foreach (var item in assemblyDefinition.CustomAttributes)
             {
                 _ignoringAttributes.Add(item.AttributeType.FullName);
             }
 
+            // check CustomAttributes against list of classes to exclude
+            foreach (var item in assemblyDefinition.CustomAttributes)
+            {
+                // add it to ignore list, if it's not already there
+                if (ClassNamesToExclude.Contains(item.AttributeType.FullName) &&
+                    !_ignoringAttributes.Contains(item.AttributeType.FullName))
+                {
+                    _ignoringAttributes.Add(item.AttributeType.FullName);
+                }
+            }
+
             NativeMethodsCrc = new NativeMethodsCrc(assemblyDefinition);
 
             var mainModule = AssemblyDefinition.MainModule;
@@ -101,6 +115,20 @@ public nanoTablesContext(
             var typeReferences = mainModule.GetTypeReferences()
                 .Where(item => !IsAttribute(item))
                 .ToList();
+
+            // copy collection to remove classes to exclude
+            TypeReference[] typeReferencesCopy = new TypeReference[typeReferences.Count];
+            typeReferences.CopyTo(typeReferencesCopy);
+
+            // compare against classes to remove
+            foreach (TypeReference t in typeReferencesCopy)
+            {
+                if (ClassNamesToExclude.Contains(t.FullName))
+                {
+                    typeReferences.Remove(t);
+                }
+            }
+
             TypeReferencesTable = new nanoTypeReferenceTable(
                 typeReferences, this);
 
@@ -231,6 +259,8 @@ public ushort GetMethodReferenceId(
 
         public nanoResourceFileTable ResourceFileTable { get; private set; }
 
+        public List<string> ClassNamesToExclude { get; private set; }
+
         private IEnumerable<Tuple<CustomAttribute, ushort>> GetAttributes(
             IEnumerable<ICustomAttributeProvider> types,
             bool applyAttributesCompression)

source/MetadataProcessor.Core/nanoAssemblyBuilder.cs

@@ -30,12 +30,17 @@ public sealed class nanoAssemblyBuilder
         /// </param>
         public nanoAssemblyBuilder(
             AssemblyDefinition assemblyDefinition,
+            List<string> classNamesToExclude,
             List<string> explicitTypesOrder = null,
             ICustomStringSorter stringSorter = null,
             bool applyAttributesCompression = false)
         {
             _tablesContext = new nanoTablesContext(
-                assemblyDefinition, explicitTypesOrder, stringSorter, applyAttributesCompression);
+                assemblyDefinition, 
+                explicitTypesOrder,
+                classNamesToExclude,
+                stringSorter,
+                applyAttributesCompression);
         }
 
         /// <summary>