keep folder structure for copyfiles tasks

add unit test yet it is not possible to test behavior without to change fixture change overloads for default value fix comments add tests for WithFilePaths and WithStrings fix whitespace use IFileSystem instead of System.File.IO reomve unused param change logic for getting common path fix copy log message remove unnecessary casting
cake-build · Oct 21, 2016 · 6df96dc · 6df96dc
1 parent f7c8339
commit 6df96dc
Show file tree

Hide file tree

Showing 13 changed files with 133 additions and 33 deletions.
diff --git a/src/Cake.Common.Tests/Unit/IO/FileAliasesTests.cs b/src/Cake.Common.Tests/Unit/IO/FileAliasesTests.cs
@@ -304,6 +304,20 @@ public void Should_Throw_If_Any_File_Do_Not_Exist()
                     Assert.Equal("The file '/Working/file2.txt' does not exist.", result?.Message);
                 }
 
+                [Fact]
+                public void Should_Keep_Folder_Structure()
+                {
+                    // Given
+                    var fixture = new FileCopyFixture();
+
+                    // When
+                    FileAliases.CopyFiles(fixture.Context, fixture.SourceFilePaths, "./target");
+
+                    // Then
+                    fixture.TargetFiles[0].Received(1).Copy(Arg.Any<FilePath>(), true);
+                    fixture.TargetFiles[1].Received(1).Copy(Arg.Any<FilePath>(), true);
+                }
+
                 [Fact]
                 public void Should_Copy_Files()
                 {
@@ -401,6 +415,21 @@ public void Should_Throw_If_Any_File_Do_Not_Exist()
                     Assert.Equal("The file '/Working/file2.txt' does not exist.", result?.Message);
                 }
 
+                [Fact]
+                public void Should_Keep_Folder_Structure()
+                {
+                    // Given
+                    var fixture = new FileCopyFixture();
+                    var filePaths = fixture.SourceFilePaths.Select(x => x.FullPath);
+
+                    // When
+                    FileAliases.CopyFiles(fixture.Context, filePaths, "./target");
+
+                    // Then
+                    fixture.TargetFiles[0].Received(1).Copy(Arg.Any<FilePath>(), true);
+                    fixture.TargetFiles[1].Received(1).Copy(Arg.Any<FilePath>(), true);
+                }
+
                 [Fact]
                 public void Should_Copy_Files()
                 {
@@ -492,6 +521,20 @@ public void Should_Throw_If_Any_File_Do_Not_Exist()
                     Assert.Equal("The file '/Working/file2.txt' does not exist.", result?.Message);
                 }
 
+                [Fact]
+                public void Should_Keep_Folder_Structure()
+                {
+                    // Given
+                    var fixture = new FileCopyFixture();
+
+                    // When
+                    FileAliases.CopyFiles(fixture.Context, "*", "./target", true);
+
+                    // Then
+                    fixture.TargetFiles[0].Received(1).Copy(Arg.Any<FilePath>(), true);
+                    fixture.TargetFiles[1].Received(1).Copy(Arg.Any<FilePath>(), true);
+                }
+
                 [Fact]
                 public void Should_Copy_Files()
                 {

diff --git a/src/Cake.Common.Tests/project.json b/src/Cake.Common.Tests/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "buildOptions": {
     "platform": "AnyCpu",
     "additionalArguments": [

diff --git a/src/Cake.Common/IO/FileAliases.cs b/src/Cake.Common/IO/FileAliases.cs
@@ -92,16 +92,17 @@ public static void CopyFile(this ICakeContext context, FilePath filePath, FilePa
         /// <param name="context">The context.</param>
         /// <param name="pattern">The pattern.</param>
         /// <param name="targetDirectoryPath">The target directory path.</param>
+        /// <param name="preserveFolderStructure">Keep the folder structure.</param>
         /// <example>
         /// <code>
         /// CopyFiles("Cake.*", "./publish");
         /// </code>
         /// </example>
         [CakeMethodAlias]
         [CakeAliasCategory("Copy")]
-        public static void CopyFiles(this ICakeContext context, string pattern, DirectoryPath targetDirectoryPath)
+        public static void CopyFiles(this ICakeContext context, string pattern, DirectoryPath targetDirectoryPath, bool preserveFolderStructure = false)
         {
-            FileCopier.CopyFiles(context, pattern, targetDirectoryPath);
+            FileCopier.CopyFiles(context, pattern, targetDirectoryPath, preserveFolderStructure);
         }
 
         /// <summary>
@@ -110,6 +111,7 @@ public static void CopyFiles(this ICakeContext context, string pattern, Director
         /// <param name="context">The context.</param>
         /// <param name="filePaths">The file paths.</param>
         /// <param name="targetDirectoryPath">The target directory path.</param>
+        /// <param name="preserveFolderStructure">Keep the folder structure.</param>
         /// <example>
         /// <code>
         /// var files = GetFiles("./**/Cake.*");
@@ -118,9 +120,9 @@ public static void CopyFiles(this ICakeContext context, string pattern, Director
         /// </example>
         [CakeMethodAlias]
         [CakeAliasCategory("Copy")]
-        public static void CopyFiles(this ICakeContext context, IEnumerable<FilePath> filePaths, DirectoryPath targetDirectoryPath)
+        public static void CopyFiles(this ICakeContext context, IEnumerable<FilePath> filePaths, DirectoryPath targetDirectoryPath, bool preserveFolderStructure = false)
         {
-            FileCopier.CopyFiles(context, filePaths, targetDirectoryPath);
+            FileCopier.CopyFiles(context, filePaths, targetDirectoryPath, preserveFolderStructure);
         }
 
         /// <summary>
@@ -129,6 +131,7 @@ public static void CopyFiles(this ICakeContext context, IEnumerable<FilePath> fi
         /// <param name="context">The context.</param>
         /// <param name="filePaths">The file paths.</param>
         /// <param name="targetDirectoryPath">The target directory path.</param>
+        /// <param name="preserveFolderStructure">Keep the folder structure.</param>
         /// <example>
         /// <code>
         /// CreateDirectory("destination");
@@ -141,14 +144,14 @@ public static void CopyFiles(this ICakeContext context, IEnumerable<FilePath> fi
         /// </example>
         [CakeMethodAlias]
         [CakeAliasCategory("Copy")]
-        public static void CopyFiles(this ICakeContext context, IEnumerable<string> filePaths, DirectoryPath targetDirectoryPath)
+        public static void CopyFiles(this ICakeContext context, IEnumerable<string> filePaths, DirectoryPath targetDirectoryPath, bool preserveFolderStructure = false)
         {
             if (filePaths == null)
             {
                 throw new ArgumentNullException(nameof(filePaths));
             }
             var paths = filePaths.Select(p => new FilePath(p));
-            FileCopier.CopyFiles(context, paths, targetDirectoryPath);
+            FileCopier.CopyFiles(context, paths, targetDirectoryPath, preserveFolderStructure);
         }
 
         /// <summary>

diff --git a/src/Cake.Common/IO/FileCopier.cs b/src/Cake.Common/IO/FileCopier.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
+using System.Linq;
 using Cake.Core;
 using Cake.Core.Diagnostics;
 using Cake.Core.IO;
@@ -56,61 +57,95 @@ public static void CopyFile(ICakeContext context, FilePath filePath, FilePath ta
                 throw new DirectoryNotFoundException(message);
             }
 
-            CopyFileCore(context, filePath, targetFilePath);
+            CopyFileCore(context, filePath, targetFilePath, null);
         }
 
-        public static void CopyFiles(ICakeContext context, string pattern, DirectoryPath targetDirectoryPath)
+        public static void CopyFiles(ICakeContext context, string pattern, DirectoryPath targetDirectoryPath, bool preserverFolderStructure)
         {
             if (context == null)
             {
-                throw new ArgumentNullException(nameof(context));
+                throw new ArgumentNullException("context");
             }
             if (pattern == null)
             {
-                throw new ArgumentNullException(nameof(pattern));
+                throw new ArgumentNullException("pattern");
             }
             var files = context.GetFiles(pattern);
+
             if (files.Count == 0)
             {
                 context.Log.Verbose("The provided pattern did not match any files.");
                 return;
             }
-            CopyFiles(context, files, targetDirectoryPath);
+            CopyFiles(context, files, targetDirectoryPath, preserverFolderStructure);
         }
 
-        public static void CopyFiles(ICakeContext context, IEnumerable<FilePath> filePaths, DirectoryPath targetDirectoryPath)
+        public static void CopyFiles(ICakeContext context, IEnumerable<FilePath> filePaths, DirectoryPath targetDirectoryPath, bool preserverFolderStructure)
         {
             if (context == null)
             {
-                throw new ArgumentNullException(nameof(context));
+                throw new ArgumentNullException("context");
             }
             if (filePaths == null)
             {
-                throw new ArgumentNullException(nameof(filePaths));
+                throw new ArgumentNullException("filePaths");
             }
             if (targetDirectoryPath == null)
             {
-                throw new ArgumentNullException(nameof(targetDirectoryPath));
+                throw new ArgumentNullException("targetDirectoryPath");
             }
 
             var absoluteTargetDirectoryPath = targetDirectoryPath.MakeAbsolute(context.Environment);
 
             // Make sure the target directory exist.
             if (!context.FileSystem.Exist(absoluteTargetDirectoryPath))
             {
-                const string format = "The directory '{0}' does not exist.";
+                const string format = "The directory '{0}' do not exist.";
                 var message = string.Format(CultureInfo.InvariantCulture, format, absoluteTargetDirectoryPath.FullPath);
                 throw new DirectoryNotFoundException(message);
             }
 
-            // Iterate all files and copy them.
-            foreach (var filePath in filePaths)
+            if (preserverFolderStructure)
+            {
+                var commonPath = string.Empty;
+                List<string> separatedPath = filePaths
+                .First(str => str.ToString().Length == filePaths.Max(st2 => st2.ToString().Length)).ToString()
+                .Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries)
+                .ToList();
+
+                foreach (string pathSegment in separatedPath)
+                {
+                    if (commonPath.Length == 0 && filePaths.All(str => str.ToString().StartsWith(pathSegment)))
+                    {
+                        commonPath = pathSegment;
+                    }
+                    else if (filePaths.All(str => str.ToString().StartsWith(commonPath + "/" + pathSegment)))
+                    {
+                        commonPath += "/" + pathSegment;
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+
+                // Iterate all files and copy them.
+                foreach (var filePath in filePaths)
+                {
+                    CopyFileCore(context, filePath, absoluteTargetDirectoryPath.GetFilePath(filePath), context.DirectoryExists(commonPath) ? commonPath : null);
+                }
+            }
+            else
             {
-                CopyFileCore(context, filePath, absoluteTargetDirectoryPath.GetFilePath(filePath));
+                // Iterate all files and copy them.
+                foreach (var filePath in filePaths)
+                {
+                    CopyFileCore(context, filePath, absoluteTargetDirectoryPath.GetFilePath(filePath), null);
+                }
             }
         }
 
-        private static void CopyFileCore(ICakeContext context, FilePath filePath, FilePath targetFilePath)
+        private static void CopyFileCore(ICakeContext context, FilePath filePath, FilePath targetFilePath, string commonPath)
         {
             var absoluteFilePath = filePath.MakeAbsolute(context.Environment);
 
@@ -124,9 +159,28 @@ private static void CopyFileCore(ICakeContext context, FilePath filePath, FilePa
 
             // Copy the file.
             var absoluteTargetPath = targetFilePath.MakeAbsolute(context.Environment);
-            context.Log.Verbose("Copying file {0} to {1}", absoluteFilePath.GetFilename(), absoluteTargetPath);
             var file = context.FileSystem.GetFile(absoluteFilePath);
-            file.Copy(absoluteTargetPath, true);
+
+            if (!string.IsNullOrEmpty(commonPath))
+            {
+                // Get the parent folder structure and create it.
+                var newRelativeFolderPath = context.Directory(commonPath).Path.GetRelativePath(filePath.GetDirectory());
+                var newTargetPath = targetFilePath.GetDirectory().Combine(newRelativeFolderPath);
+                var newAbsoluteTargetPath = newTargetPath.CombineWithFilePath(filePath.GetFilename());
+                context.Log.Verbose("Copying file {0} to {1}", absoluteFilePath.GetFilename(), newAbsoluteTargetPath);
+
+                if (!context.DirectoryExists(newTargetPath))
+                {
+                    context.CreateDirectory(newTargetPath);
+                }
+
+                file.Copy(newAbsoluteTargetPath, true);
+            }
+            else
+            {
+                context.Log.Verbose("Copying file {0} to {1}", absoluteFilePath.GetFilename(), absoluteTargetPath);
+                file.Copy(absoluteTargetPath, true);
+            }
         }
     }
-}
+}
diff --git a/src/Cake.Common/project.json b/src/Cake.Common/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "description": "Provides aliases (extension methods on Cake context) that support CI, build, unit tests, zip, signing, etc. for Cake.",
   "copyright": "Copyright (c) .NET Foundation and contributors",
   "authors": [

diff --git a/src/Cake.Core.Tests/project.json b/src/Cake.Core.Tests/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "dependencies": {
     "dotnet-test-xunit": "2.2.0-preview2-build1029",
     "Cake.Core": {

diff --git a/src/Cake.Core/project.json b/src/Cake.Core/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "description": "The Cake core library.",
   "copyright": "Copyright (c) .NET Foundation and contributors",
   "authors": [

diff --git a/src/Cake.NuGet.Tests/project.json b/src/Cake.NuGet.Tests/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "buildOptions": {
     "platform": "AnyCpu",
     "additionalArguments": [

diff --git a/src/Cake.NuGet/project.json b/src/Cake.NuGet/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "dependencies": {
     "Cake.Core": {
       "target": "project"

diff --git a/src/Cake.Testing.Xunit/project.json b/src/Cake.Testing.Xunit/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "configurations": {
     "Release": {
       "buildOptions": {

diff --git a/src/Cake.Testing/project.json b/src/Cake.Testing/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "description": "Contains testing utilities for Cake.",
   "copyright": "Copyright (c) .NET Foundation and contributors",
   "authors": [

diff --git a/src/Cake.Tests/project.json b/src/Cake.Tests/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "dependencies": {
     "dotnet-test-xunit": "2.2.0-preview2-build1029",
     "Cake": {

diff --git a/src/Cake/project.json b/src/Cake/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0-*",
+  "version": "0.15.3-*",
   "buildOptions": {
     "emitEntryPoint": true,
     "xmlDoc": true,