Singular argument name, code cleanup, cwd change

ViktorHofer · ViktorHofer · commit d6e008fba9af · 2018-11-28T16:36:52.000+01:00
diff --git a/README.md b/README.md
@@ -56,19 +56,19 @@ Arguments:
   <ASSEMBLY>  Path to the test assembly.
 
 Options:
-  -h|--help              Show help information
-  -v|--version           Show version information
-  -t|--target            Path to the test runner application.
-  -a|--targetargs        Arguments to be passed to the test runner.
-  -o|--output            Output of the generated coverage report
-  -f|--format            Format of the generated coverage report.
-  --threshold            Exits with error if the coverage % is below value.
-  --threshold-type       Coverage type to apply the threshold to.
-  --exclude              Filter expressions to exclude specific modules and types.
-  --include              Filter expressions to include specific modules and types.
-  --include-directories  Include directories containing additional assemblies to be instrumented.
-  --exclude-by-file      Glob patterns specifying source files to exclude.
-  --merge-with           Path to existing coverage result to merge.
+  -h|--help            Show help information
+  -v|--version         Show version information
+  -t|--target          Path to the test runner application.
+  -a|--targetargs      Arguments to be passed to the test runner.
+  -o|--output          Output of the generated coverage report
+  -f|--format          Format of the generated coverage report.
+  --threshold          Exits with error if the coverage % is below value.
+  --threshold-type     Coverage type to apply the threshold to.
+  --exclude            Filter expressions to exclude specific modules and types.
+  --include            Filter expressions to include specific modules and types.
+  --include-directory  Include directories containing additional assemblies to be instrumented.
+  --exclude-by-file    Glob patterns specifying source files to exclude.
+  --merge-with         Path to existing coverage result to merge.
 ```
 
 #### Code Coverage
diff --git a/src/coverlet.console/Program.cs b/src/coverlet.console/Program.cs
@@ -32,7 +32,7 @@ static int Main(string[] args)
             CommandOption thresholdTypes = app.Option("--threshold-type", "Coverage type to apply the threshold to.", CommandOptionType.MultipleValue);
             CommandOption excludeFilters = app.Option("--exclude", "Filter expressions to exclude specific modules and types.", CommandOptionType.MultipleValue);
             CommandOption includeFilters = app.Option("--include", "Filter expressions to include only specific modules and types.", CommandOptionType.MultipleValue);
-            CommandOption includeDirectories = app.Option("--include-directories", "Include directories containing additional assemblies to be instrumented.", CommandOptionType.MultipleValue);
+            CommandOption includeDirectories = app.Option("--include-directory", "Include directories containing additional assemblies to be instrumented.", CommandOptionType.MultipleValue);
             CommandOption excludedSourceFiles = app.Option("--exclude-by-file", "Glob patterns specifying source files to exclude.", CommandOptionType.MultipleValue);
             CommandOption mergeWith = app.Option("--merge-with", "Path to existing coverage result to merge.", CommandOptionType.SingleValue);
 
diff --git a/src/coverlet.core/Coverage.cs b/src/coverlet.core/Coverage.cs
@@ -66,8 +66,8 @@ public void PrepareModules()
                     }
                     catch (Exception)
                     {
+                        // TODO: With verbose logging we should note that instrumentation failed.
                         InstrumentationHelper.RestoreOriginalModule(module, _identifier);
-                        throw;
                     }
                 }
             }
diff --git a/src/coverlet.core/Helpers/InstrumentationHelper.cs b/src/coverlet.core/Helpers/InstrumentationHelper.cs
@@ -14,39 +14,41 @@ namespace Coverlet.Core.Helpers
 {
     internal static class InstrumentationHelper
     {
-        public static string[] GetCoverableModules(string module, string[] includeDirectories)
+        public static string[] GetCoverableModules(string module, string[] directories)
         {
-            Debug.Assert(includeDirectories != null, "Parameter " + nameof(includeDirectories) + " in method " + 
-                nameof(InstrumentationHelper) + "." + nameof(GetCoverableModules) + " must not be null");
+            Debug.Assert(directories != null);
 
             string moduleDirectory = Path.GetDirectoryName(module);
             if (moduleDirectory == string.Empty)
             {
                 moduleDirectory = Directory.GetCurrentDirectory();
             }
 
-            var dirs = new List<string>(1 + includeDirectories.Length)
+            var dirs = new List<string>()
             {
                 // Add the test assembly's directory.
                 moduleDirectory
             };
 
-            // Prepare all the directories in which we probe for modules.
-            foreach (var includeDirectory in includeDirectories.Where(d => d != null))
+            // Prepare all the directories we probe for modules.
+            foreach (string directory in directories)
             {
-                var fullPath = (!Path.IsPathRooted(includeDirectory)
-                    ? Path.GetFullPath(Path.Combine(moduleDirectory, includeDirectory))
-                    : includeDirectory).TrimEnd('*');
+                if (string.IsNullOrWhiteSpace(directory)) continue;
+
+                string fullPath = (!Path.IsPathRooted(directory)
+                    ? Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), directory))
+                    : directory).TrimEnd('*');
 
                 if (!Directory.Exists(fullPath)) continue;
 
-                if (includeDirectory.EndsWith("*", StringComparison.Ordinal))
+                if (directory.EndsWith("*", StringComparison.Ordinal))
                     dirs.AddRange(Directory.GetDirectories(fullPath));
                 else
                     dirs.Add(fullPath);
             }
 
-            // The test module's name must be unique.
+            // The module's name must be unique.
+            // Add the test module itself to exclude it from the files enumeration.
             var uniqueModules = new HashSet<string>
             {
                 Path.GetFileName(module)
@@ -309,8 +311,7 @@ private static string WildcardToRegex(string pattern)
 
         private static bool IsAssembly(string filePath)
         {
-            Debug.Assert(filePath != null, "Parameter " + nameof(filePath) + " in " + nameof(InstrumentationHelper) + 
-                "." + nameof(IsAssembly) + " must not be null.");
+            Debug.Assert(filePath != null);
 
             if (!(filePath.EndsWith(".exe") || filePath.EndsWith(".dll")))
                 return false;
diff --git a/src/coverlet.msbuild.tasks/InstrumentationTask.cs b/src/coverlet.msbuild.tasks/InstrumentationTask.cs
@@ -11,7 +11,7 @@ public class InstrumentationTask : Task
         private string _path;
         private string _exclude;
         private string _include;
-        private string _includeDirectories;
+        private string _includeDirectory;
         private string _excludeByFile;
         private string _mergeWith;
 
@@ -39,10 +39,10 @@ public string Include
             set { _include = value; }
         }
 
-        public string IncludeDirectories
+        public string IncludeDirectory
         {
-            get { return _includeDirectories; }
-            set { _includeDirectories = value; }
+            get { return _includeDirectory; }
+            set { _includeDirectory = value; }
         }
 
         public string ExcludeByFile
@@ -64,7 +64,7 @@ public override bool Execute()
                 var excludedSourceFiles = _excludeByFile?.Split(',');
                 var excludeFilters = _exclude?.Split(',');
                 var includeFilters = _include?.Split(',');
-                var includeDirectories = _includeDirectories?.Split(',');
+                var includeDirectories = _includeDirectory?.Split(',');
 
                 _coverage = new Coverage(_path, excludeFilters, includeFilters, includeDirectories, excludedSourceFiles, _mergeWith);
                 _coverage.PrepareModules();
diff --git a/src/coverlet.msbuild/coverlet.msbuild.props b/src/coverlet.msbuild/coverlet.msbuild.props
@@ -9,6 +9,6 @@
     <MergeWith Condition="$(MergeWith) == ''"></MergeWith>
     <Threshold Condition="$(Threshold) == ''">0</Threshold>
     <ThresholdType Condition="$(ThresholdType) == ''">line,branch,method</ThresholdType>
-    <IncludeDirectories Condition="$(IncludeDirectories) == ''"></IncludeDirectories>
+    <IncludeDirectory Condition="$(IncludeDirectory) == ''"></IncludeDirectory>
   </PropertyGroup>
 </Project>
diff --git a/src/coverlet.msbuild/coverlet.msbuild.targets b/src/coverlet.msbuild/coverlet.msbuild.targets
@@ -7,7 +7,7 @@
     <Coverlet.MSbuild.Tasks.InstrumentationTask
       Condition="'$(VSTestNoBuild)' == 'true' and $(CollectCoverage) == 'true'"
       Include="$(Include)"
-      IncludeDirectories="$(IncludeDirectories)"
+      IncludeDirectory="$(IncludeDirectory)"
       Exclude="$(Exclude)"
       ExcludeByFile="$(ExcludeByFile)"
       MergeWith="$(MergeWith)"
@@ -18,7 +18,7 @@
     <Coverlet.MSbuild.Tasks.InstrumentationTask
       Condition="'$(VSTestNoBuild)' != 'true' and $(CollectCoverage) == 'true'"
       Include="$(Include)"
-      IncludeDirectories="$(IncludeDirectories)"
+      IncludeDirectory="$(IncludeDirectory)"
       Exclude="$(Exclude)"
       ExcludeByFile="$(ExcludeByFile)"
       MergeWith="$(MergeWith)"

Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,8 @@ public void PrepareModules()`
`66`	`66`	`}`
`67`	`67`	`catch (Exception)`
`68`	`68`	`{`
	`69`	`+ // TODO: With verbose logging we should note that instrumentation failed.`
`69`	`70`	`InstrumentationHelper.RestoreOriginalModule(module, _identifier);`
`70`		`- throw;`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,39 +14,41 @@ namespace Coverlet.Core.Helpers`
`14`	`14`	`{`
`15`	`15`	`internal static class InstrumentationHelper`
`16`	`16`	`{`
`17`		`- public static string[] GetCoverableModules(string module, string[] includeDirectories)`
	`17`	`+ public static string[] GetCoverableModules(string module, string[] directories)`
`18`	`18`	`{`
`19`		`- Debug.Assert(includeDirectories != null, "Parameter " + nameof(includeDirectories) + " in method " +`
`20`		`- nameof(InstrumentationHelper) + "." + nameof(GetCoverableModules) + " must not be null");`
	`19`	`+ Debug.Assert(directories != null);`
`21`	`20`
`22`	`21`	`string moduleDirectory = Path.GetDirectoryName(module);`
`23`	`22`	`if (moduleDirectory == string.Empty)`
`24`	`23`	`{`
`25`	`24`	`moduleDirectory = Directory.GetCurrentDirectory();`
`26`	`25`	`}`
`27`	`26`
`28`		`- var dirs = new List<string>(1 + includeDirectories.Length)`
	`27`	`+ var dirs = new List<string>()`
`29`	`28`	`{`
`30`	`29`	`// Add the test assembly's directory.`
`31`	`30`	`moduleDirectory`
`32`	`31`	`};`
`33`	`32`
`34`		`- // Prepare all the directories in which we probe for modules.`
`35`		`- foreach (var includeDirectory in includeDirectories.Where(d => d != null))`
	`33`	`+ // Prepare all the directories we probe for modules.`
	`34`	`+ foreach (string directory in directories)`
`36`	`35`	`{`
`37`		`- var fullPath = (!Path.IsPathRooted(includeDirectory)`
`38`		`- ? Path.GetFullPath(Path.Combine(moduleDirectory, includeDirectory))`
`39`		`- : includeDirectory).TrimEnd('*');`
	`36`	`+ if (string.IsNullOrWhiteSpace(directory)) continue;`
	`37`	`+`
	`38`	`+ string fullPath = (!Path.IsPathRooted(directory)`
	`39`	`+ ? Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), directory))`
	`40`	`+ : directory).TrimEnd('*');`
`40`	`41`
`41`	`42`	`if (!Directory.Exists(fullPath)) continue;`
`42`	`43`
`43`		`- if (includeDirectory.EndsWith("*", StringComparison.Ordinal))`
	`44`	`+ if (directory.EndsWith("*", StringComparison.Ordinal))`
`44`	`45`	`dirs.AddRange(Directory.GetDirectories(fullPath));`
`45`	`46`	`else`
`46`	`47`	`dirs.Add(fullPath);`
`47`	`48`	`}`
`48`	`49`
`49`		`- // The test module's name must be unique.`
	`50`	`+ // The module's name must be unique.`
	`51`	`+ // Add the test module itself to exclude it from the files enumeration.`
`50`	`52`	`var uniqueModules = new HashSet<string>`
`51`	`53`	`{`
`52`	`54`	`Path.GetFileName(module)`
`@@ -309,8 +311,7 @@ private static string WildcardToRegex(string pattern)`
`309`	`311`
`310`	`312`	`private static bool IsAssembly(string filePath)`
`311`	`313`	`{`
`312`		`- Debug.Assert(filePath != null, "Parameter " + nameof(filePath) + " in " + nameof(InstrumentationHelper) +`
`313`		`- "." + nameof(IsAssembly) + " must not be null.");`
	`314`	`+ Debug.Assert(filePath != null);`
`314`	`315`
`315`	`316`	`if (!(filePath.EndsWith(".exe") \|\| filePath.EndsWith(".dll")))`
`316`	`317`	`return false;`