Feature configurable output directory

FineCodeCoverage/Core/Cobertura/CoberturaUtil.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using FineCodeCoverage.Engine.Model;
 using System.ComponentModel.Composition;
+using System.IO;
 
 namespace FineCodeCoverage.Engine.Cobertura
 {
@@ -16,9 +17,9 @@ internal class CoberturaUtil:ICoberturaUtil
 		private CoverageReport coverageReport;
 		public List<CoverageLine> CoverageLines { get; private set; }
 
-		private CoverageReport LoadReportFile(string inputFilePath)
+		private CoverageReport LoadReport(string xml)
 		{
-			using (var reader = XmlReader.Create(inputFilePath, READER_SETTINGS))
+			using (var reader = XmlReader.Create(new StringReader(xml), READER_SETTINGS))
 			{
 				var report = (CoverageReport)SERIALIZER.Deserialize(reader);
 				return report;
@@ -67,11 +68,11 @@ private CoverageReport LoadReportFile(string inputFilePath)
 		//	return jsonText;
 		//}
 
-		public void ProcessCoberturaXmlFile(string xmlFilePath)
+		public void ProcessCoberturaXml(string xml)
 		{
 			CoverageLines = new List<CoverageLine>();
 
-			coverageReport = LoadReportFile(xmlFilePath);
+			coverageReport = LoadReport(xml);
 
 			foreach (var package in coverageReport.Packages.Package)
 			{

FineCodeCoverage/Core/Cobertura/ICoberturaUtil.cs

@@ -7,7 +7,7 @@ interface ICoberturaUtil
     {
 		List<CoverageLine> CoverageLines { get; }
 
-		void ProcessCoberturaXmlFile(string xmlFilePath);
+		void ProcessCoberturaXml(string xml);
 		string[] GetSourceFiles(string assemblyName, string qualifiedClassName, int file);
 	}
 }

FineCodeCoverage/Core/CoverageToolOutput/AppOptionsCoverageToolOutputFolderSolutionProvider.cs

@@ -0,0 +1,33 @@
+using System;
+using System.ComponentModel.Composition;
+using System.IO;
+using FineCodeCoverage.Core.Utilities;
+using FineCodeCoverage.Options;
+
+namespace FineCodeCoverage.Engine
+{
+    [Order(1, typeof(ICoverageToolOutputFolderSolutionProvider))]
+    class AppOptionsCoverageToolOutputFolderSolutionProvider : ICoverageToolOutputFolderSolutionProvider
+    {
+        private readonly IAppOptionsProvider appOptionsProvider;
+
+        [ImportingConstructor]
+        public AppOptionsCoverageToolOutputFolderSolutionProvider(IAppOptionsProvider appOptionsProvider)
+        {
+            this.appOptionsProvider = appOptionsProvider;
+        }
+        public string Provide(Func<string> solutionFolderProvider)
+        {
+            var appOptions = appOptionsProvider.Get();
+            if (!String.IsNullOrEmpty(appOptions.FCCSolutionOutputDirectoryName))
+            {
+                var solutionFolder = solutionFolderProvider();
+                if(solutionFolder != null)
+                {
+                    return Path.Combine(solutionFolder, appOptions.FCCSolutionOutputDirectoryName);
+                }
+            }
+            return null;
+        }
+    }
+}

FineCodeCoverage/Core/CoverageToolOutput/CoverageToolOutputFolderFromSolutionProvider.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using FineCodeCoverage.Core.Utilities;
+using FineCodeCoverage.Engine.Model;
+
+namespace FineCodeCoverage.Engine
+{
+    [Order(1, typeof(ICoverageToolOutputFolderProvider))]
+    class CoverageToolOutputFolderFromSolutionProvider : ICoverageToolOutputFolderProvider
+    {
+        private readonly ISolutionFolderProvider solutionFolderProvider;
+        private readonly IOrderedEnumerable<Lazy<ICoverageToolOutputFolderSolutionProvider, IOrderMetadata>> solutionFolderProviders;
+
+        [ImportingConstructor]
+        public CoverageToolOutputFolderFromSolutionProvider(ISolutionFolderProvider solutionFolderProvider, [ImportMany] IEnumerable<Lazy<ICoverageToolOutputFolderSolutionProvider, IOrderMetadata>> solutionFolderProviders)
+        {
+            this.solutionFolderProvider = solutionFolderProvider;
+            this.solutionFolderProviders = solutionFolderProviders.OrderBy(p => p.Metadata.Order);
+        }
+
+        public string Provide(List<ICoverageProject> coverageProjects)
+        {
+            var provided = false;
+            string providedDirectory = null;
+            return solutionFolderProviders.SelectFirstNonNull(p => p.Value.Provide(() =>
+            {
+                if(!provided)
+                {
+                    providedDirectory = solutionFolderProvider.Provide(coverageProjects[0].ProjectFile);
+                    provided = true;
+                }
+                return providedDirectory;
+            }));
+
+        }
+    }
+}

FineCodeCoverage/Core/CoverageToolOutput/CoverageToolOutputManager.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Linq;
+using FineCodeCoverage.Core.Utilities;
+using FineCodeCoverage.Engine.Model;
+
+namespace FineCodeCoverage.Engine
+{
+    [Export(typeof(ICoverageToolOutputManager))]
+    internal class CoverageToolOutputManager : ICoverageToolOutputManager
+    {
+        private readonly ILogger logger;
+        private readonly IFileUtil fileUtil;
+        private const string unifiedHtmlFileName = "index.html";
+        private const string unifiedXmlFileName = "Cobertura.xml";
+        private const string processedHtmlFileName = "index-processed.html";
+        private const string projectCoverageToolOutputFolderName = "coverage-tool-output";
+        private string outputFolderForAllProjects;
+        private List<ICoverageProject> coverageProjects;
+        private readonly IOrderedEnumerable<Lazy<ICoverageToolOutputFolderProvider, IOrderMetadata>> outputFolderProviders;
+
+        [ImportingConstructor]
+        public CoverageToolOutputManager(IFileUtil fileUtil, ILogger logger,[ImportMany] IEnumerable<Lazy<ICoverageToolOutputFolderProvider, IOrderMetadata>> outputFolderProviders)
+        {
+            this.logger = logger;
+            this.fileUtil = fileUtil;
+            this.outputFolderProviders = outputFolderProviders.OrderBy(p => p.Metadata.Order);
+        }
+
+        public void SetProjectCoverageOutputFolder(List<ICoverageProject> coverageProjects)
+        {
+            this.coverageProjects = coverageProjects;
+            DetermineOutputFolder();
+            if (outputFolderForAllProjects == null)
+            {
+                foreach(var coverageProject in coverageProjects)
+                {
+                    coverageProject.CoverageOutputFolder = Path.Combine(coverageProject.FCCOutputFolder, projectCoverageToolOutputFolderName);
+                }
+            }
+            else
+            {
+                fileUtil.TryEmptyDirectory(outputFolderForAllProjects);
+                foreach (var coverageProject in coverageProjects)
+                {
+                    coverageProject.CoverageOutputFolder = Path.Combine(outputFolderForAllProjects, coverageProject.ProjectName);
+                }
+            }
+        }
+
+        public void OutputReports(string unifiedHtml, string processedReport, string unifiedXml)
+        {
+            var outputFolder = outputFolderForAllProjects ?? coverageProjects[0].CoverageOutputFolder;
+
+            fileUtil.WriteAllText(Path.Combine(outputFolder, unifiedHtmlFileName), unifiedHtml);
+            fileUtil.WriteAllText(Path.Combine(outputFolder, processedHtmlFileName), processedReport);
+            fileUtil.WriteAllText(Path.Combine(outputFolder, unifiedXmlFileName), unifiedXml);
+        }
+
+        private void DetermineOutputFolder()
+        {
+            outputFolderForAllProjects = outputFolderProviders.SelectFirstNonNull(p => p.Value.Provide(coverageProjects));
+            if(outputFolderForAllProjects != null)
+            {
+                logger.Log($"FCC output in {outputFolderForAllProjects}");
+            }
+        }
+    }
+}

FineCodeCoverage/Core/CoverageToolOutput/FccOutputExistenceCoverageToolOutputFolderSolutionProvider.cs

@@ -0,0 +1,34 @@
+using System;
+using System.ComponentModel.Composition;
+using System.IO;
+using FineCodeCoverage.Core.Utilities;
+
+namespace FineCodeCoverage.Engine
+{
+    [Order(2,typeof(ICoverageToolOutputFolderSolutionProvider))]
+    class FccOutputExistenceCoverageToolOutputFolderSolutionProvider : ICoverageToolOutputFolderSolutionProvider
+    {
+        private const string fccOutputFolderName = "fcc-output";
+        private readonly IFileUtil fileUtil;
+
+        [ImportingConstructor]
+        public FccOutputExistenceCoverageToolOutputFolderSolutionProvider(IFileUtil fileUtil)
+        {
+            this.fileUtil = fileUtil;
+        }
+
+        public string Provide(Func<string> solutionFolderProvider)
+        {
+            var solutionFolder = solutionFolderProvider();
+            if (solutionFolder != null)
+            {
+                var provided = Path.Combine(solutionFolder, fccOutputFolderName);
+                if (fileUtil.DirectoryExists(provided))
+                {
+                    return provided;
+                }
+            }
+            return null;
+        }
+    }
+}

FineCodeCoverage/Core/CoverageToolOutput/ICoverageToolOutputFolderProvider.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using FineCodeCoverage.Engine.Model;
+
+namespace FineCodeCoverage.Engine
+{
+    internal interface ICoverageToolOutputFolderProvider
+    {
+        string Provide(List<ICoverageProject> coverageProjects);
+    }
+}

FineCodeCoverage/Core/CoverageToolOutput/ICoverageToolOutputFolderSolutionProvider.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace FineCodeCoverage.Engine
+{
+    interface ICoverageToolOutputFolderSolutionProvider
+    {
+        string Provide(Func<string> solutionFolderProvider);
+    }
+}

FineCodeCoverage/Core/CoverageToolOutput/ICoverageToolOutputManager.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using FineCodeCoverage.Engine.Model;
+
+namespace FineCodeCoverage.Engine
+{
+    internal interface ICoverageToolOutputManager
+    {
+        void SetProjectCoverageOutputFolder(List<ICoverageProject> coverageProjects);
+        void OutputReports(string unifiedHtml, string processedReport, string unifiedXml);
+    }
+}

FineCodeCoverage/Core/CoverageToolOutput/ISolutionFolderProvider.cs

@@ -0,0 +1,7 @@
+namespace FineCodeCoverage.Engine
+{
+    interface ISolutionFolderProvider
+    {
+        string Provide(string projectFile);
+    }
+}

FineCodeCoverage/Core/CoverageToolOutput/SolutionFolderProvider.cs

@@ -0,0 +1,27 @@
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Linq;
+
+namespace FineCodeCoverage.Engine
+{
+    [Export(typeof(ISolutionFolderProvider))]
+    class SolutionFolderProvider : ISolutionFolderProvider
+    {
+        public string Provide(string projectFile)
+        {
+            string provided = null;
+            var directory = new FileInfo(projectFile).Directory;
+            while(directory != null)
+            {
+                var isSolutionDirectory = directory.EnumerateFiles().Any(f => f.Name.EndsWith(".sln"));
+                if (isSolutionDirectory)
+                {
+                    provided = directory.FullName;
+                    break;
+                }
+                directory = directory.Parent;
+            }
+            return provided;
+        }
+    }
+}