Clean up code for unused methods and unused architectures

Author: Justin Chung

src/code/RuntimeIdentifierHelper.cs

@@ -42,14 +42,6 @@ internal static class RuntimeIdentifierHelper
         /// A RID string like "win-x64", "linux-x64", "osx-arm64", etc.
         /// Follows the .NET RID catalog: https://learn.microsoft.com/en-us/dotnet/core/rid-catalog
         /// </returns>
-        /// <example>
-        /// Windows 64-bit: "win-x64"
-        /// Windows 32-bit: "win-x86"
-        /// Linux 64-bit: "linux-x64"
-        /// Alpine Linux: "linux-musl-x64"
-        /// macOS Intel: "osx-x64"
-        /// macOS Apple Silicon: "osx-arm64"
-        /// </example>
         public static string GetCurrentRuntimeIdentifier()
         {
             if (s_currentRid != null)
@@ -252,16 +244,6 @@ private static string GetArchitectureString()
                 Architecture.X86 => "x86",
                 Architecture.Arm => "arm",
                 Architecture.Arm64 => "arm64",
-#if NET6_0_OR_GREATER
-                Architecture.S390x => "s390x",
-                Architecture.Ppc64le => "ppc64le",
-#endif
-#if NET7_0_OR_GREATER
-                Architecture.LoongArch64 => "loongarch64",
-#endif
-#if NET8_0_OR_GREATER
-                Architecture.Armv6 => "arm",
-#endif
                 _ => processArch.ToString().ToLowerInvariant()
             };
         }

src/code/RuntimePackageHelper.cs

@@ -175,227 +175,6 @@ public static IReadOnlyList<string> GetAvailableRidsFromZipFile(string zipPath)
             }
         }
 
-        /// <summary>
-        /// Gets statistics about the runtime assets in a package, showing what would be included vs excluded.
-        /// </summary>
-        /// <param name="archive">The zip archive to analyze.</param>
-        /// <returns>A RuntimeFilterStats object with filtering statistics.</returns>
-        public static RuntimeFilterStats GetFilteringStatistics(ZipArchive archive)
-        {
-            if (archive == null)
-            {
-                throw new ArgumentNullException(nameof(archive));
-            }
-
-            var stats = new RuntimeFilterStats
-            {
-                CurrentRid = RuntimeIdentifierHelper.GetCurrentRuntimeIdentifier(),
-                CompatibleRids = RuntimeIdentifierHelper.GetCompatibleRuntimeIdentifiers().ToList()
-            };
-
-            foreach (ZipArchiveEntry entry in archive.Entries)
-            {
-                if (entry.Length == 0)
-                {
-                    continue; // Skip directories
-                }
-
-                if (IsRuntimesEntry(entry.FullName))
-                {
-                    string rid = GetRidFromRuntimesEntry(entry.FullName);
-                    
-                    if (ShouldIncludeEntry(entry.FullName))
-                    {
-                        stats.IncludedRuntimeEntriesCount++;
-                        stats.IncludedRuntimeEntriesSize += entry.Length;
-                        
-                        if (!string.IsNullOrEmpty(rid))
-                        {
-                            if (!stats.IncludedRids.Contains(rid))
-                            {
-                                stats.IncludedRids.Add(rid);
-                            }
-                        }
-                    }
-                    else
-                    {
-                        stats.ExcludedRuntimeEntriesCount++;
-                        stats.ExcludedRuntimeEntriesSize += entry.Length;
-                        
-                        if (!string.IsNullOrEmpty(rid))
-                        {
-                            if (!stats.ExcludedRids.Contains(rid))
-                            {
-                                stats.ExcludedRids.Add(rid);
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    stats.NonRuntimeEntriesCount++;
-                    stats.NonRuntimeEntriesSize += entry.Length;
-                }
-            }
-
-            return stats;
-        }
-
-        /// <summary>
-        /// Filters zip entries based on the current platform's RID.
-        /// Returns only entries that should be extracted for this platform.
-        /// </summary>
-        /// <param name="entries">The collection of zip entries to filter.</param>
-        /// <returns>Filtered entries that should be extracted.</returns>
-        public static IEnumerable<ZipArchiveEntry> FilterEntriesForCurrentPlatform(IEnumerable<ZipArchiveEntry> entries)
-        {
-            if (entries == null)
-            {
-                throw new ArgumentNullException(nameof(entries));
-            }
-
-            foreach (ZipArchiveEntry entry in entries)
-            {
-                if (ShouldIncludeEntry(entry.FullName))
-                {
-                    yield return entry;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Checks if a package has any platform-specific runtime assets.
-        /// </summary>
-        /// <param name="archive">The zip archive to check.</param>
-        /// <returns>True if the package contains runtime assets; otherwise, false.</returns>
-        public static bool HasRuntimeAssets(ZipArchive archive)
-        {
-            if (archive == null)
-            {
-                return false;
-            }
-
-            foreach (ZipArchiveEntry entry in archive.Entries)
-            {
-                if (IsRuntimesEntry(entry.FullName))
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
         #endregion
     }
-
-    /// <summary>
-    /// Statistics about runtime asset filtering for a package.
-    /// </summary>
-    internal class RuntimeFilterStats
-    {
-        /// <summary>
-        /// The current platform's runtime identifier.
-        /// </summary>
-        public string CurrentRid { get; set; }
-
-        /// <summary>
-        /// List of RIDs compatible with the current platform.
-        /// </summary>
-        public List<string> CompatibleRids { get; set; } = new List<string>();
-
-        /// <summary>
-        /// RIDs that will be included in the installation.
-        /// </summary>
-        public List<string> IncludedRids { get; set; } = new List<string>();
-
-        /// <summary>
-        /// RIDs that will be excluded from the installation.
-        /// </summary>
-        public List<string> ExcludedRids { get; set; } = new List<string>();
-
-        /// <summary>
-        /// Number of non-runtime entries in the package.
-        /// </summary>
-        public int NonRuntimeEntriesCount { get; set; }
-
-        /// <summary>
-        /// Total size of non-runtime entries in bytes.
-        /// </summary>
-        public long NonRuntimeEntriesSize { get; set; }
-
-        /// <summary>
-        /// Number of runtime entries that will be included.
-        /// </summary>
-        public int IncludedRuntimeEntriesCount { get; set; }
-
-        /// <summary>
-        /// Total size of included runtime entries in bytes.
-        /// </summary>
-        public long IncludedRuntimeEntriesSize { get; set; }
-
-        /// <summary>
-        /// Number of runtime entries that will be excluded.
-        /// </summary>
-        public int ExcludedRuntimeEntriesCount { get; set; }
-
-        /// <summary>
-        /// Total size of excluded runtime entries in bytes.
-        /// </summary>
-        public long ExcludedRuntimeEntriesSize { get; set; }
-
-        /// <summary>
-        /// Total size of all entries in the package in bytes.
-        /// </summary>
-        public long TotalPackageSize => NonRuntimeEntriesSize + IncludedRuntimeEntriesSize + ExcludedRuntimeEntriesSize;
-
-        /// <summary>
-        /// Total size that will be installed in bytes.
-        /// </summary>
-        public long InstalledSize => NonRuntimeEntriesSize + IncludedRuntimeEntriesSize;
-
-        /// <summary>
-        /// Total size that will be saved by filtering in bytes.
-        /// </summary>
-        public long SavedSize => ExcludedRuntimeEntriesSize;
-
-        /// <summary>
-        /// Percentage of space saved by filtering.
-        /// </summary>
-        public double SavedPercentage => TotalPackageSize > 0 
-            ? (double)SavedSize / TotalPackageSize * 100 
-            : 0;
-
-        /// <summary>
-        /// Returns a human-readable summary of the filtering statistics.
-        /// </summary>
-        public override string ToString()
-        {
-            return $"Current RID: {CurrentRid}\n" +
-                   $"Compatible RIDs: {string.Join(", ", CompatibleRids)}\n" +
-                   $"Included RIDs: {string.Join(", ", IncludedRids)}\n" +
-                   $"Excluded RIDs: {string.Join(", ", ExcludedRids)}\n" +
-                   $"Non-runtime files: {NonRuntimeEntriesCount} ({FormatBytes(NonRuntimeEntriesSize)})\n" +
-                   $"Included runtime files: {IncludedRuntimeEntriesCount} ({FormatBytes(IncludedRuntimeEntriesSize)})\n" +
-                   $"Excluded runtime files: {ExcludedRuntimeEntriesCount} ({FormatBytes(ExcludedRuntimeEntriesSize)})\n" +
-                   $"Total package size: {FormatBytes(TotalPackageSize)}\n" +
-                   $"Installed size: {FormatBytes(InstalledSize)}\n" +
-                   $"Space saved: {FormatBytes(SavedSize)} ({SavedPercentage:F1}%)";
-        }
-
-        private static string FormatBytes(long bytes)
-        {
-            string[] suffixes = { "B", "KB", "MB", "GB" };
-            int suffixIndex = 0;
-            double size = bytes;
-
-            while (size >= 1024 && suffixIndex < suffixes.Length - 1)
-            {
-                size /= 1024;
-                suffixIndex++;
-            }
-
-            return $"{size:F2} {suffixes[suffixIndex]}";
-        }
-    }
 }