R# cleanup

asbjornu · JakeGinnivan · commit 1f9973ea5ae5 · 2016-01-17T09:02:05.000+08:00
diff --git a/src/GitVersionTask.Tests/GitVersionTaskDirectoryTests.cs b/src/GitVersionTask.Tests/GitVersionTaskDirectoryTests.cs
@@ -1,37 +1,41 @@
 ﻿using System;
 using System.IO;
+
 using LibGit2Sharp;
+
 using NUnit.Framework;
 
 [TestFixture]
 public class GitVersionTaskDirectoryTests
 {
-    string workDirectory;
     string gitDirectory;
+    string workDirectory;
+
 
     [SetUp]
     public void CreateTemporaryRepository()
     {
-        workDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        this.workDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        this.gitDirectory = Repository.Init(this.workDirectory)
+            .TrimEnd(Path.DirectorySeparatorChar);
 
-        gitDirectory = Repository.Init(workDirectory)
-                        .TrimEnd(new[] { Path.DirectorySeparatorChar });
-
-        Assert.NotNull(gitDirectory);
+        Assert.NotNull(this.gitDirectory);
     }
 
+
     [TearDown]
     public void Cleanup()
     {
-        Directory.Delete(workDirectory, true);
+        Directory.Delete(this.workDirectory, true);
     }
 
+
     [Test]
     public void Finds_GitDirectory()
     {
         try
         {
-            VersionAndBranchFinder.GetVersion(workDirectory, null, true, null);
+            VersionAndBranchFinder.GetVersion(this.workDirectory, null, true, null);
         }
         catch (Exception ex)
         {
@@ -41,10 +45,11 @@ public void Finds_GitDirectory()
         }
     }
 
+
     [Test]
     public void Finds_GitDirectory_In_Parent()
     {
-        var childDir = Path.Combine(workDirectory, "child");
+        var childDir = Path.Combine(this.workDirectory, "child");
         Directory.CreateDirectory(childDir);
 
         try
@@ -58,4 +63,4 @@ public void Finds_GitDirectory_In_Parent()
             Assert.IsNotAssignableFrom<RepositoryNotFoundException>(ex);
         }
     }
-}
+}
diff --git a/src/GitVersionTask/AssemblyInfoBuilder/UpdateAssemblyInfo.cs b/src/GitVersionTask/AssemblyInfoBuilder/UpdateAssemblyInfo.cs
@@ -3,14 +3,30 @@
     using System;
     using System.IO;
     using System.Text;
+
     using GitVersion;
     using GitVersion.Helpers;
+
     using Microsoft.Build.Framework;
-    using Microsoft.Build.Utilities;
-    using Logger = GitVersion.Logger;
 
     public class UpdateAssemblyInfo : Task
     {
+        IFileSystem fileSystem;
+
+        TaskLogger logger;
+
+
+        public UpdateAssemblyInfo()
+        {
+            CompileFiles = new ITaskItem[]
+            {
+            };
+            this.logger = new TaskLogger(this);
+            this.fileSystem = new FileSystem();
+            Logger.SetLoggers(this.LogInfo, this.LogWarning, s => this.LogError(s));
+        }
+
+
         [Required]
         public string SolutionDirectory { get; set; }
 
@@ -31,19 +47,6 @@ public class UpdateAssemblyInfo : Task
 
         public bool NoFetch { get; set; }
 
-        TaskLogger logger;
-        IFileSystem fileSystem;
-
-        public UpdateAssemblyInfo()
-        {
-            CompileFiles = new ITaskItem[] { };
-            logger = new TaskLogger(this);
-            fileSystem = new FileSystem();
-            Logger.SetLoggers(
-                this.LogInfo,
-                this.LogWarning,
-                s => this.LogError(s));
-        }
 
         public override bool Execute()
         {
@@ -54,12 +57,12 @@ public override bool Execute()
             }
             catch (WarningException errorException)
             {
-                logger.LogWarning(errorException.Message);
+                this.logger.LogWarning(errorException.Message);
                 return true;
             }
             catch (Exception exception)
             {
-                logger.LogError("Error occurred: " + exception);
+                this.logger.LogError("Error occurred: " + exception);
                 return false;
             }
             finally
@@ -68,20 +71,22 @@ public override bool Execute()
             }
         }
 
-        public void InnerExecute()
+
+        void InnerExecute()
         {
             TempFileTracker.DeleteTempFiles();
 
             InvalidFileChecker.CheckForInvalidFiles(CompileFiles, ProjectFile);
 
             VersionVariables versionVariables;
-            if (!VersionAndBranchFinder.TryGetVersion(SolutionDirectory, out versionVariables, NoFetch, new Authentication(), fileSystem))
+            if (!VersionAndBranchFinder.TryGetVersion(SolutionDirectory, out versionVariables, NoFetch, new Authentication()))
             {
                 return;
             }
             CreateTempAssemblyInfo(versionVariables);
         }
 
+
         void CreateTempAssemblyInfo(VersionVariables versionVariables)
         {
             if (IntermediateOutputPath == null)
@@ -105,7 +110,9 @@ void CreateTempAssemblyInfo(VersionVariables versionVariables)
                 {
                     var content = File.ReadAllText(AssemblyInfoTempFilePath, Encoding.UTF8).Trim();
                     if (string.Equals(assemblyInfo, content, StringComparison.Ordinal))
+                    {
                         return; // nothign to do as the file matches what we'd create
+                    }
                 }
             }
             catch (Exception)
diff --git a/src/GitVersionTask/GetVersion.cs b/src/GitVersionTask/GetVersion.cs
@@ -9,6 +9,17 @@
 
     public class GetVersion : Task
     {
+        TaskLogger logger;
+
+
+        public GetVersion()
+        {
+            this.logger = new TaskLogger(this);
+            this.fileSystem = new FileSystem();
+            Logger.SetLoggers(this.LogInfo, this.LogWarning, s => this.LogError(s));
+        }
+
+
         [Required]
         public string SolutionDirectory { get; set; }
 
@@ -80,19 +91,8 @@ public class GetVersion : Task
         [Output]
         public string CommitsSinceVersionSourcePadded { get; set; }
 
-        TaskLogger logger;
         IFileSystem fileSystem;
 
-        public GetVersion()
-        {
-            logger = new TaskLogger(this);
-            fileSystem = new FileSystem();
-            Logger.SetLoggers(
-                this.LogInfo,
-                this.LogWarning,
-                s => this.LogError(s));
-        }
-
         public override bool Execute()
         {
             try
@@ -111,12 +111,12 @@ public override bool Execute()
             }
             catch (WarningException errorException)
             {
-                logger.LogWarning(errorException.Message);
+                this.logger.LogWarning(errorException.Message);
                 return true;
             }
             catch (Exception exception)
             {
-                logger.LogError("Error occurred: " + exception);
+                this.logger.LogError("Error occurred: " + exception);
                 return false;
             }
             finally
diff --git a/src/GitVersionTask/VersionAndBranchFinder.cs b/src/GitVersionTask/VersionAndBranchFinder.cs
@@ -103,18 +103,20 @@ static VersionVariables LoadVersionVariablesFromDiskCache(string key, string dir
                 vv.FileName = cacheFileName;
 
                 using (var stream = fileSystem.OpenWrite(cacheFileName))
-                using (var sw = new StreamWriter(stream))
                 {
-                    Dictionary<string, string> dictionary;
-                    using (Logger.IndentLog("Creating dictionary"))
+                    using (var sw = new StreamWriter(stream))
                     {
-                        dictionary = vv.ToDictionary(x => x.Key, x => x.Value);
-                    }
+                        Dictionary<string, string> dictionary;
+                        using (Logger.IndentLog("Creating dictionary"))
+                        {
+                            dictionary = vv.ToDictionary(x => x.Key, x => x.Value);
+                        }
 
-                    using (Logger.IndentLog("Storing version variables to cache file " + cacheFileName))
-                    {
-                        var serializer = new Serializer();
-                        serializer.Serialize(sw, dictionary);
+                        using (Logger.IndentLog("Storing version variables to cache file " + cacheFileName))
+                        {
+                            var serializer = new Serializer();
+                            serializer.Serialize(sw, dictionary);
+                        }
                     }
                 }
             }
diff --git a/src/GitVersionTask/WriteVersionInfoToBuildLog.cs b/src/GitVersionTask/WriteVersionInfoToBuildLog.cs
@@ -1,33 +1,33 @@
 ﻿namespace GitVersionTask
 {
+    using System;
+    using System.Collections.Generic;
+
     using GitVersion;
     using GitVersion.Helpers;
+
     using Microsoft.Build.Framework;
-    using Microsoft.Build.Utilities;
-    using System;
-    using System.Collections.Generic;
-    using Logger = GitVersion.Logger;
 
     public class WriteVersionInfoToBuildLog : Task
     {
-        [Required]
-        public string SolutionDirectory { get; set; }
-
-        public bool NoFetch { get; set; }
+        readonly IFileSystem fileSystem;
+        readonly TaskLogger logger;
 
-        TaskLogger logger;
-        IFileSystem fileSystem;
 
         public WriteVersionInfoToBuildLog()
         {
-            logger = new TaskLogger(this);
-            fileSystem = new FileSystem();
-            Logger.SetLoggers(
-                this.LogInfo,
-                this.LogWarning,
-                s => this.LogError(s));
+            this.logger = new TaskLogger(this);
+            this.fileSystem = new FileSystem();
+            Logger.SetLoggers(this.LogInfo, this.LogWarning, s => this.LogError(s));
         }
 
+
+        [Required]
+        public string SolutionDirectory { get; set; }
+
+        public bool NoFetch { get; set; }
+
+
         public override bool Execute()
         {
             try
@@ -37,12 +37,12 @@ public override bool Execute()
             }
             catch (WarningException errorException)
             {
-                logger.LogWarning(errorException.Message);
+                this.logger.LogWarning(errorException.Message);
                 return true;
             }
             catch (Exception exception)
             {
-                logger.LogError("Error occurred: " + exception);
+                this.logger.LogError("Error occurred: " + exception);
                 return false;
             }
             finally
@@ -51,27 +51,29 @@ public override bool Execute()
             }
         }
 
-        public void InnerExecute()
+
+        void InnerExecute()
         {
             VersionVariables result;
             if (!VersionAndBranchFinder.TryGetVersion(SolutionDirectory, out result, NoFetch, new Authentication(), fileSystem))
             {
                 return;
             }
-            
+
             WriteIntegrationParameters(BuildServerList.GetApplicableBuildServers(), result);
         }
 
-        public void WriteIntegrationParameters(IEnumerable<IBuildServer> applicableBuildServers, VersionVariables variables)
+
+        void WriteIntegrationParameters(IEnumerable<IBuildServer> applicableBuildServers, VersionVariables variables)
         {
             foreach (var buildServer in applicableBuildServers)
             {
-                logger.LogInfo(string.Format("Executing GenerateSetVersionMessage for '{0}'.", buildServer.GetType().Name));
-                logger.LogInfo(buildServer.GenerateSetVersionMessage(variables));
-                logger.LogInfo(string.Format("Executing GenerateBuildLogOutput for '{0}'.", buildServer.GetType().Name));
+                this.logger.LogInfo(string.Format("Executing GenerateSetVersionMessage for '{0}'.", buildServer.GetType().Name));
+                this.logger.LogInfo(buildServer.GenerateSetVersionMessage(variables));
+                this.logger.LogInfo(string.Format("Executing GenerateBuildLogOutput for '{0}'.", buildServer.GetType().Name));
                 foreach (var buildParameter in BuildOutputFormatter.GenerateBuildLogOutput(buildServer, variables))
                 {
-                    logger.LogInfo(buildParameter);
+                    this.logger.LogInfo(buildParameter);
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -1,37 +1,41 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.IO;`
	`3`	`+`
`3`	`4`	`using LibGit2Sharp;`
	`5`	`+`
`4`	`6`	`using NUnit.Framework;`
`5`	`7`
`6`	`8`	`[TestFixture]`
`7`	`9`	`public class GitVersionTaskDirectoryTests`
`8`	`10`	`{`
`9`		`- string workDirectory;`
`10`	`11`	`string gitDirectory;`
	`12`	`+ string workDirectory;`
	`13`	`+`
`11`	`14`
`12`	`15`	`[SetUp]`
`13`	`16`	`public void CreateTemporaryRepository()`
`14`	`17`	`{`
`15`		`- workDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());`
	`18`	`+ this.workDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());`
	`19`	`+ this.gitDirectory = Repository.Init(this.workDirectory)`
	`20`	`+ .TrimEnd(Path.DirectorySeparatorChar);`
`16`	`21`
`17`		`- gitDirectory = Repository.Init(workDirectory)`
`18`		`- .TrimEnd(new[] { Path.DirectorySeparatorChar });`
`19`		`-`
`20`		`- Assert.NotNull(gitDirectory);`
	`22`	`+ Assert.NotNull(this.gitDirectory);`
`21`	`23`	`}`
`22`	`24`
	`25`	`+`
`23`	`26`	`[TearDown]`
`24`	`27`	`public void Cleanup()`
`25`	`28`	`{`
`26`		`- Directory.Delete(workDirectory, true);`
	`29`	`+ Directory.Delete(this.workDirectory, true);`
`27`	`30`	`}`
`28`	`31`
	`32`	`+`
`29`	`33`	`[Test]`
`30`	`34`	`public void Finds_GitDirectory()`
`31`	`35`	`{`
`32`	`36`	`try`
`33`	`37`	`{`
`34`		`- VersionAndBranchFinder.GetVersion(workDirectory, null, true, null);`
	`38`	`+ VersionAndBranchFinder.GetVersion(this.workDirectory, null, true, null);`
`35`	`39`	`}`
`36`	`40`	`catch (Exception ex)`
`37`	`41`	`{`
`@@ -41,10 +45,11 @@ public void Finds_GitDirectory()`
`41`	`45`	`}`
`42`	`46`	`}`
`43`	`47`
	`48`	`+`
`44`	`49`	`[Test]`
`45`	`50`	`public void Finds_GitDirectory_In_Parent()`
`46`	`51`	`{`
`47`		`- var childDir = Path.Combine(workDirectory, "child");`
	`52`	`+ var childDir = Path.Combine(this.workDirectory, "child");`
`48`	`53`	`Directory.CreateDirectory(childDir);`
`49`	`54`
`50`	`55`	`try`
`@@ -58,4 +63,4 @@ public void Finds_GitDirectory_In_Parent()`
`58`	`63`	`Assert.IsNotAssignableFrom<RepositoryNotFoundException>(ex);`
`59`	`64`	`}`
`60`	`65`	`}`
`61`		`-}`
	`66`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -103,18 +103,20 @@ static VersionVariables LoadVersionVariablesFromDiskCache(string key, string dir`
`103`	`103`	`vv.FileName = cacheFileName;`
`104`	`104`
`105`	`105`	`using (var stream = fileSystem.OpenWrite(cacheFileName))`
`106`		`- using (var sw = new StreamWriter(stream))`
`107`	`106`	`{`
`108`		`- Dictionary<string, string> dictionary;`
`109`		`- using (Logger.IndentLog("Creating dictionary"))`
	`107`	`+ using (var sw = new StreamWriter(stream))`
`110`	`108`	`{`
`111`		`- dictionary = vv.ToDictionary(x => x.Key, x => x.Value);`
`112`		`- }`
	`109`	`+ Dictionary<string, string> dictionary;`
	`110`	`+ using (Logger.IndentLog("Creating dictionary"))`
	`111`	`+ {`
	`112`	`+ dictionary = vv.ToDictionary(x => x.Key, x => x.Value);`
	`113`	`+ }`
`113`	`114`
`114`		`- using (Logger.IndentLog("Storing version variables to cache file " + cacheFileName))`
`115`		`- {`
`116`		`- var serializer = new Serializer();`
`117`		`- serializer.Serialize(sw, dictionary);`
	`115`	`+ using (Logger.IndentLog("Storing version variables to cache file " + cacheFileName))`
	`116`	`+ {`
	`117`	`+ var serializer = new Serializer();`
	`118`	`+ serializer.Serialize(sw, dictionary);`
	`119`	`+ }`
`118`	`120`	`}`
`119`	`121`	`}`
`120`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,33 +1,33 @@`
`1`	`1`	`namespace GitVersionTask`
`2`	`2`	`{`
	`3`	`+ using System;`
	`4`	`+ using System.Collections.Generic;`
	`5`	`+`
`3`	`6`	`using GitVersion;`
`4`	`7`	`using GitVersion.Helpers;`
	`8`	`+`
`5`	`9`	`using Microsoft.Build.Framework;`
`6`		`- using Microsoft.Build.Utilities;`
`7`		`- using System;`
`8`		`- using System.Collections.Generic;`
`9`		`- using Logger = GitVersion.Logger;`
`10`	`10`
`11`	`11`	`public class WriteVersionInfoToBuildLog : Task`
`12`	`12`	`{`
`13`		`- [Required]`
`14`		`- public string SolutionDirectory { get; set; }`
`15`		`-`
`16`		`- public bool NoFetch { get; set; }`
	`13`	`+ readonly IFileSystem fileSystem;`
	`14`	`+ readonly TaskLogger logger;`
`17`	`15`
`18`		`- TaskLogger logger;`
`19`		`- IFileSystem fileSystem;`
`20`	`16`
`21`	`17`	`public WriteVersionInfoToBuildLog()`
`22`	`18`	`{`
`23`		`- logger = new TaskLogger(this);`
`24`		`- fileSystem = new FileSystem();`
`25`		`- Logger.SetLoggers(`
`26`		`- this.LogInfo,`
`27`		`- this.LogWarning,`
`28`		`- s => this.LogError(s));`
	`19`	`+ this.logger = new TaskLogger(this);`
	`20`	`+ this.fileSystem = new FileSystem();`
	`21`	`+ Logger.SetLoggers(this.LogInfo, this.LogWarning, s => this.LogError(s));`
`29`	`22`	`}`
`30`	`23`
	`24`	`+`
	`25`	`+ [Required]`
	`26`	`+ public string SolutionDirectory { get; set; }`
	`27`	`+`
	`28`	`+ public bool NoFetch { get; set; }`
	`29`	`+`
	`30`	`+`
`31`	`31`	`public override bool Execute()`
`32`	`32`	`{`
`33`	`33`	`try`
`@@ -37,12 +37,12 @@ public override bool Execute()`
`37`	`37`	`}`
`38`	`38`	`catch (WarningException errorException)`
`39`	`39`	`{`
`40`		`- logger.LogWarning(errorException.Message);`
	`40`	`+ this.logger.LogWarning(errorException.Message);`
`41`	`41`	`return true;`
`42`	`42`	`}`
`43`	`43`	`catch (Exception exception)`
`44`	`44`	`{`
`45`		`- logger.LogError("Error occurred: " + exception);`
	`45`	`+ this.logger.LogError("Error occurred: " + exception);`
`46`	`46`	`return false;`
`47`	`47`	`}`
`48`	`48`	`finally`
`@@ -51,27 +51,29 @@ public override bool Execute()`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`- public void InnerExecute()`
	`54`	`+`
	`55`	`+ void InnerExecute()`
`55`	`56`	`{`
`56`	`57`	`VersionVariables result;`
`57`	`58`	`if (!VersionAndBranchFinder.TryGetVersion(SolutionDirectory, out result, NoFetch, new Authentication(), fileSystem))`
`58`	`59`	`{`
`59`	`60`	`return;`
`60`	`61`	`}`
`61`		`-`
	`62`	`+`
`62`	`63`	`WriteIntegrationParameters(BuildServerList.GetApplicableBuildServers(), result);`
`63`	`64`	`}`
`64`	`65`
`65`		`- public void WriteIntegrationParameters(IEnumerable<IBuildServer> applicableBuildServers, VersionVariables variables)`
	`66`	`+`
	`67`	`+ void WriteIntegrationParameters(IEnumerable<IBuildServer> applicableBuildServers, VersionVariables variables)`
`66`	`68`	`{`
`67`	`69`	`foreach (var buildServer in applicableBuildServers)`
`68`	`70`	`{`
`69`		`- logger.LogInfo(string.Format("Executing GenerateSetVersionMessage for '{0}'.", buildServer.GetType().Name));`
`70`		`- logger.LogInfo(buildServer.GenerateSetVersionMessage(variables));`
`71`		`- logger.LogInfo(string.Format("Executing GenerateBuildLogOutput for '{0}'.", buildServer.GetType().Name));`
	`71`	`+ this.logger.LogInfo(string.Format("Executing GenerateSetVersionMessage for '{0}'.", buildServer.GetType().Name));`
	`72`	`+ this.logger.LogInfo(buildServer.GenerateSetVersionMessage(variables));`
	`73`	`+ this.logger.LogInfo(string.Format("Executing GenerateBuildLogOutput for '{0}'.", buildServer.GetType().Name));`
`72`	`74`	`foreach (var buildParameter in BuildOutputFormatter.GenerateBuildLogOutput(buildServer, variables))`
`73`	`75`	`{`
`74`		`- logger.LogInfo(buildParameter);`
	`76`	`+ this.logger.LogInfo(buildParameter);`
`75`	`77`	`}`
`76`	`78`	`}`
`77`	`79`	`}`