organized files, worked on tar.gz support, filter and flatten support

Author: ayousuf23

src/CompressArchiveCommand.cs renamed to src/Cmdlets/CompressArchiveCommand.cs

@@ -55,18 +55,25 @@ private enum ParameterSet
         [NotNull]
         public string? DestinationPath { get; set; }
 
-        [Parameter()]
+        [Parameter]
         public WriteMode WriteMode { get; set; }
 
-        [Parameter()]
+        [Parameter]
         public SwitchParameter PassThru { get; set; }
 
-        [Parameter()]
+        [Parameter]
         [ValidateNotNullOrEmpty]
         public CompressionLevel CompressionLevel { get; set; }
 
-        [Parameter()]
-        public ArchiveFormat? Format { get; set; } = null;
+        [Parameter]
+        public ArchiveFormat? Format { get; set; }
+
+        [Parameter]
+        [ValidateNotNullOrEmpty]
+        public string? Filter { get; set; }
+
+        [Parameter]
+        public SwitchParameter Flatten { get; set; }
 
         private readonly PathHelper _pathHelper;
 
@@ -161,6 +168,8 @@ protected override void EndProcessing()
             // Get archive entries
             // If a path causes an exception (e.g., SecurityException), _pathHelper should handle it
             Debug.Assert(_paths is not null);
+            _pathHelper.Flatten = Flatten;
+            _pathHelper.Filter = Filter;
             List<ArchiveAddition> archiveAdditions = _pathHelper.GetArchiveAdditions(_paths);
 
             // Remove references to _paths, Path, and LiteralPath to free up memory

src/ExpandArchiveCommand.cs renamed to src/Cmdlets/ExpandArchiveCommand.cs

@@ -46,8 +46,6 @@ private enum ParameterSet {
 
         private PathHelper _pathHelper;
 
-        private System.IO.FileSystemInfo? _destinationPathInfo;
-
         private bool _didCreateOutput;
 
         private string? _sourcePath;
@@ -56,9 +54,7 @@ private enum ParameterSet {
 
         public ExpandArchiveCommand()
         {
-            _didCreateOutput = false;
             _pathHelper = new PathHelper(cmdlet: this);
-            _destinationPathInfo = null;
         }
 
         protected override void BeginProcessing()
@@ -189,10 +185,6 @@ private void ProcessArchiveEntry(IEntry entry)
                 postExpandPath = postExpandPath.Remove(postExpandPath.Length - 1);
             }
 
-            // Notify the user that we are expanding the entry
-            //var expandingEntryMsg = string.Format(Messages.ExpandingEntryMessage, entry.Name, postExpandPath);
-            //WriteObject(expandingEntryMsg);
-
             // If the entry name is invalid, write a non-terminating error and stop processing the entry
             if (IsPathInvalid(postExpandPath))
             {

src/ErrorMessages.cs renamed to src/Error.cs

@@ -12,19 +12,19 @@ namespace Microsoft.PowerShell.Archive
 {
     internal class GzipArchive : IArchive
     {
-        private bool _disposedValue;
+        protected bool _disposedValue;
 
-        private readonly ArchiveMode _mode;
+        protected readonly ArchiveMode _mode;
 
-        private readonly string _path;
+        protected readonly string _path;
 
-        private readonly FileStream _fileStream;
+        protected readonly FileStream _fileStream;
 
-        private readonly CompressionLevel _compressionLevel;
+        protected readonly CompressionLevel _compressionLevel;
 
         private bool _addedFile;
 
-        private bool _didCallGetNextEntry;
+        protected bool _didCallGetNextEntry;
 
         ArchiveMode IArchive.Mode => _mode;
 
@@ -38,7 +38,7 @@ public GzipArchive(string path, ArchiveMode mode, FileStream fileStream, Compres
             _compressionLevel = compressionLevel;
         }
 
-        void IArchive.AddFileSystemEntry(ArchiveAddition entry)
+        public virtual void AddFileSystemEntry(ArchiveAddition entry)
         {
             if (_mode == ArchiveMode.Extract)
             {

src/GzipArchive.cs renamed to src/Formats/GzipArchive.cs

@@ -38,7 +38,7 @@ public TarArchive(string path, ArchiveMode mode, FileStream fileStream)
             _fileStream = fileStream;
         }
 
-        void IArchive.AddFileSystemEntry(ArchiveAddition entry)
+        public void AddFileSystemEntry(ArchiveAddition entry)
         {
             if (_mode == ArchiveMode.Extract)
             {

src/TarArchive.cs renamed to src/Formats/TarArchive.cs

@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Formats.Tar;
+using System.IO;
+using System.IO.Compression;
+using System.Diagnostics;
+
+namespace Microsoft.PowerShell.Archive
+{
+    internal class TarGzArchive : GzipArchive
+    {
+
+        // Use a tar archive because .tar.gz file is a compressed tar file
+        private TarArchive? _tarArchive;
+
+        private string? _tarFilePath;
+
+        private FileStream? _tarFileStream;
+
+        public TarGzArchive(string path, ArchiveMode mode, FileStream fileStream, CompressionLevel compressionLevel) : base(path, mode, fileStream, compressionLevel)
+        {
+        }
+
+        public override void AddFileSystemEntry(ArchiveAddition entry)
+        {
+            if (_mode == ArchiveMode.Extract || _mode == ArchiveMode.Update) {
+                throw new ArgumentException("Adding entries to the archive is not supported in extract or update mode");
+            }
+
+            if (_tarArchive is null)
+            {
+                var outputDirectory = Path.GetDirectoryName(_path);
+                var tarFilename = Path.GetRandomFileName();
+                _tarFilePath = Path.Combine(outputDirectory, tarFilename);
+                _tarFileStream = new FileStream(_tarFilePath, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None);
+                _tarArchive = new TarArchive(_tarFilePath, ArchiveMode.Create, _tarFileStream);
+                
+            }
+            _tarArchive.AddFileSystemEntry(entry);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposedValue)
+            {
+                if (disposing)
+                {
+                    // TODO: dispose managed state (managed objects)
+                    _fileStream.Dispose();
+                    CompressArchive();
+                }
+
+                // TODO: free unmanaged resources (unmanaged objects) and override finalizer
+                // TODO: set large fields to null
+                _disposedValue = true;
+            }
+        }
+
+        // Performs gzip compression on _path
+        private void CompressArchive() {
+            Debug.Assert(_tarFileStream is not null);
+            _tarFileStream.Position = 0;
+            using var gzipCompressor = new GZipStream(_fileStream, _compressionLevel, true);
+            _tarFileStream.CopyTo(gzipCompressor);
+        }
+    }
+}

src/Formats/TarGzArchive.cs

@@ -7,22 +7,22 @@
 
 namespace Microsoft.PowerShell.Archive
 {
-    internal interface IArchive: IDisposable
+    interface IArchive: IDisposable
     {
         // Get what mode the archive is in
-        internal ArchiveMode Mode { get; }
+        public ArchiveMode Mode { get; }
 
         // Get the fully qualified path of the archive
-        internal string Path { get; }
+        public string Path { get; }
 
         // Add a file or folder to the archive. The entry name of the added item in the
         // will be ArchiveEntry.Name.
         // Throws an exception if the archive is in read mode.
-        internal void AddFileSystemEntry(ArchiveAddition entry);
+        public void AddFileSystemEntry(ArchiveAddition entry);
 
-        internal IEntry? GetNextEntry();
+        public IEntry? GetNextEntry();
 
         // Does the archive have only a top-level directory?
-        internal bool HasTopLevelDirectory();
+        public bool HasTopLevelDirectory();
     }
 }

src/ZipArchive.cs renamed to src/Formats/ZipArchive.cs

@@ -17,20 +17,29 @@ internal class PathHelper
 
         private const string FileSystemProviderName = "FileSystem";
 
+        internal bool Flatten { get; set; }
+
+        internal string? Filter { get; set; }
+
+        internal WildcardPattern? _wildCardPattern;
+
         internal PathHelper(PSCmdlet cmdlet)
         {
             _cmdlet = cmdlet;
         }
 
         internal List<ArchiveAddition> GetArchiveAdditions(HashSet<string> fullyQualifiedPaths)
         {
+            if (Filter is not null) {
+                _wildCardPattern = new WildcardPattern(Filter);
+            } 
             List<ArchiveAddition> archiveAdditions = new List<ArchiveAddition>(fullyQualifiedPaths.Count);
             foreach (var path in fullyQualifiedPaths)
             {
                 // Assume each path is valid, fully qualified, and existing
                 Debug.Assert(Path.Exists(path));
                 Debug.Assert(Path.IsPathFullyQualified(path));
-                AddAdditionForFullyQualifiedPath(path, archiveAdditions);
+                AddAdditionForFullyQualifiedPath(path, archiveAdditions, entryName: null, parentMatchesFilter: false);
             }
             return archiveAdditions;
         }
@@ -41,7 +50,7 @@ internal List<ArchiveAddition> GetArchiveAdditions(HashSet<string> fullyQualifie
         /// <param name="path">The fully qualified path</param>
         /// <param name="additions">The list where to add the ArchiveAddition object for the path</param>
         /// <param name="shouldPreservePathStructure">If true, relative path structure will be preserved. If false, relative path structure will NOT be preserved.</param>
-        private void AddAdditionForFullyQualifiedPath(string path, List<ArchiveAddition> additions)
+        private void AddAdditionForFullyQualifiedPath(string path, List<ArchiveAddition> additions, string? entryName, bool parentMatchesFilter)
         {
             Debug.Assert(Path.Exists(path));
             FileSystemInfo fileSystemInfo;
@@ -61,15 +70,38 @@ private void AddAdditionForFullyQualifiedPath(string path, List<ArchiveAddition>
                 fileSystemInfo = new FileInfo(path);
             }
 
-            // Get the entry name of the file or directory in the archive
-            // The cmdlet will preserve the directory structure as long as the path is relative to the working directory
-            var entryName = GetEntryName(fileSystemInfo, out bool doesPreservePathStructure);
-            additions.Add(new ArchiveAddition(entryName: entryName, fileSystemInfo: fileSystemInfo));
+            bool doesMatchFilter = true;
+            if (!parentMatchesFilter && _wildCardPattern is not null) {
+                doesMatchFilter = _wildCardPattern.IsMatch(fileSystemInfo.Name);
+            }
+            
+            // if entryName, then set it as the entry name of the file or directory in the archive
+            // The entry name will preserve the directory structure as long as the path is relative to the working directory
+            if (entryName is null) {
+                entryName = GetEntryName(fileSystemInfo, out bool doesPreservePathStructure);
+            }
+           
+
+            // Number of elements in additions before adding this item and its descendents if it is a directory
+            int initialAdditions = additions.Count;
 
             // Recurse through the child items and add them to additions
-            if (fileSystemInfo.Attributes.HasFlag(FileAttributes.Directory) && fileSystemInfo is DirectoryInfo directoryInfo) {
-                AddDescendentEntries(directoryInfo: directoryInfo, additions: additions, shouldPreservePathStructure: doesPreservePathStructure);
+            if (fileSystemInfo.Attributes.HasFlag(FileAttributes.Directory) && fileSystemInfo is DirectoryInfo directoryInfo)
+            {
+                AddDescendentEntries(directoryInfo, additions, doesMatchFilter);
             }
+
+            // Number of elements in additions after adding this item's descendents (if directory)
+            int finalAdditions = additions.Count;
+
+            // If the item being added is a file, finalAdditions - initialAdditions = 0
+            // If the item being added is a directory and does not have any descendent files that match the filter, finalAdditions - initialAdditions = 0
+            // If the item being added is a directory and has descendent files that match the filter, finalAdditions > initialAdditions
+
+            if (doesMatchFilter || (!doesMatchFilter && finalAdditions - initialAdditions > 0)) {
+                additions.Add(new ArchiveAddition(entryName: entryName, fileSystemInfo: fileSystemInfo));
+            }
+            
         }
 
         /// <summary>
@@ -78,28 +110,41 @@ private void AddAdditionForFullyQualifiedPath(string path, List<ArchiveAddition>
         /// <param name="path">A fully qualifed path referring to a directory</param>
         /// <param name="additions">Where the ArchiveAddtion object for each child item of the directory will be added</param>
         /// <param name="shouldPreservePathStructure">See above</param>
-        private void AddDescendentEntries(System.IO.DirectoryInfo directoryInfo, List<ArchiveAddition> additions, bool shouldPreservePathStructure)
+        private void AddDescendentEntries(System.IO.DirectoryInfo directoryInfo, List<ArchiveAddition> additions, bool parentMatchesFilter)
         {
             try
             {
                 // pathPrefix is used to construct the entry names of the descendents of the directory
                 var pathPrefix = GetPrefixForPath(directoryInfo: directoryInfo);
-                foreach (var childFileSystemInfo in directoryInfo.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
+                // If the parent directory matches the filter, then we don't have to check if each individual descendent of the directory
+                // matches the filter.
+                // This reduces the total number of method calls
+                SearchOption searchOption = parentMatchesFilter ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; 
+                foreach (var childFileSystemInfo in directoryInfo.EnumerateFileSystemInfos("*", searchOption))
                 {
                     string entryName;
-                    // If the cmdlet should preserve the path structure, then use the relative path
-                    if (shouldPreservePathStructure)
+                    if (Flatten)
                     {
-                        entryName = GetEntryName(childFileSystemInfo, out bool doesPreservePathStructure);
-                        Debug.Assert(doesPreservePathStructure);
+                        entryName = childFileSystemInfo.Name;
+                    } else
+                    {
+                        entryName = GetEntryNameUsingPrefix(path: childFileSystemInfo.FullName, prefix: pathPrefix);
                     }
-                    // Otherwise, get the entry name using the prefix 
+                        
+                    
+                    // Add an entry for each descendent of the directory
+                    if (parentMatchesFilter)
+                    {
+                        // If the parent directory matches the filter, all its contents are included in the archive
+                        // Just add the entry for each child without needing to check whether the child matches the filter
+                        additions.Add(new ArchiveAddition(entryName: entryName, fileSystemInfo: childFileSystemInfo));
+                    } 
                     else
                     {
-                        entryName = GetEntryNameUsingPrefix(path: childFileSystemInfo.FullName, prefix: pathPrefix);
+                        // If the parent directory does not match the filter, we want to call this function
+                        // because this function will check if the name of the child matches the filter and if so, will add it
+                        AddAdditionForFullyQualifiedPath(childFileSystemInfo.FullName, additions, entryName, parentMatchesFilter: false);
                     }
-                    // Add an entry for each descendent of the directory                 
-                    additions.Add(new ArchiveAddition(entryName: entryName, fileSystemInfo: childFileSystemInfo));
                 }
             } 
             // Write a non-terminating error if a securityException occurs
@@ -122,7 +167,7 @@ private string GetEntryName(FileSystemInfo fileSystemInfo, out bool doesPreserve
             string entryName;
             doesPreservePathStructure = false;
             // If the path is relative to the current working directory, return the relative path as name
-            if (TryGetPathRelativeToCurrentWorkingDirectory(path: fileSystemInfo.FullName, out var relativePath))
+            if (!Flatten && TryGetPathRelativeToCurrentWorkingDirectory(path: fileSystemInfo.FullName, out var relativePath))
             {
                 Debug.Assert(relativePath is not null);
                 doesPreservePathStructure = true;