Changing project files to link to codeanalysis files

common/build.targets

@@ -5,8 +5,11 @@
     <Compile Include="$(SolutionDir)common\SolutionInfo.cs">
       <Link>Properties\SolutionInfo.cs</Link>
     </Compile>
-    <None Include="$(SolutionDir)common\GitHub.ruleset">
-      <Link>Properties\GitHub.ruleset</Link>
+    <None Include="$(SolutionDir)common\codeanalysis-release.ruleset">
+      <Link>Properties\codeanalysis-release.ruleset</Link>
+    </None>
+    <None Include="$(SolutionDir)common\codeanalysis-debug.ruleset">
+      <Link>Properties\codeanalysis-debug.ruleset</Link>
     </None>
   </ItemGroup>
 

common/codeanalysis-small.ruleset → common/codeanalysis-debug.ruleset

@@ -94,6 +94,26 @@
 
     <!-- link demand -->
     <Rule Id="CA2123" Action="None" />
+
+    <!-- disposable -->
+    <Rule Id="CA1001" Action="None" />
+
+    <!-- no we like our event handler signatures thankyouverymuch -->
+    <Rule Id="CA1009" Action="None" />
+
+    <!-- calling TryParse without using its return value is not a crime, Microsoft -->
+    <Rule Id="CA1806" Action="None" />
+
+    <!-- we're returning arrays from properties -->
+    <Rule Id="CA1819" Action="None" />
+
+    <!-- Unity does its own serialization and doesn't need special serializable type constructors -->
+    <Rule Id="CA2229" Action="None" />
+    <Rule Id="CA2240" Action="None" />
+
+    <!-- the compiler already warns about this -->
+    <Rule Id="CA1823" Action="None" />
+
   </Rules>
   <Rules AnalyzerId="Microsoft.CodeAnalysis.CSharp.Features" RuleNamespace="Microsoft.CodeAnalysis.CSharp.Features">
     <Rule Id="IDE0001" Action="None" />

common/codeanalysis-full.ruleset → common/codeanalysis-release.ruleset

@@ -80,6 +80,28 @@
     <Rule Id="CA2227" Action="None" />
     <Rule Id="CA2235" Action="None" />
     <Rule Id="IDE001" Action="None" />
+
+    <!-- link demand -->
+    <Rule Id="CA2123" Action="None" />
+
+    <!-- disposable -->
+    <Rule Id="CA1001" Action="None" />
+
+    <!-- no we like our event handler signatures thankyouverymuch -->
+    <Rule Id="CA1009" Action="None" />
+
+    <!-- calling TryParse without using its return value is not a crime, Microsoft -->
+    <Rule Id="CA1806" Action="None" />
+
+    <!-- we're returning arrays from properties -->
+    <Rule Id="CA1819" Action="None" />
+
+    <!-- Unity does its own serialization and doesn't need special serializable type constructors -->
+    <Rule Id="CA2229" Action="None" />
+    <Rule Id="CA2240" Action="None" />
+
+    <!-- the compiler already warns about this -->
+    <Rule Id="CA1823" Action="None" />
   </Rules>
   <Rules AnalyzerId="Microsoft.CodeAnalysis.CSharp.Features" RuleNamespace="Microsoft.CodeAnalysis.CSharp.Features">
     <Rule Id="IDE0001" Action="None" />

common/properties.props

@@ -12,4 +12,15 @@
     <UnityDir Condition="$(UnityDir) == '' and Exists('\Applications\Unity\Unity.app\Contents\Managed\UnityEditor.dll')">\Applications\Unity\Unity.app\Contents\Managed\</UnityDir>
     <BuildConfig Condition=" '$(BuildConfig)' == '' ">Debug</BuildConfig>
   </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <CodeAnalysisRuleSet>$(SolutionDir)\common\codeanalysis-debug.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <CodeAnalysisRuleSet>$(SolutionDir)\common\codeanalysis-release.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'dev|AnyCPU'">
+    <CodeAnalysisRuleSet>$(SolutionDir)\common\codeanalysis-debug.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+
 </Project>

src/GitHub.Api/Application/ApiClient.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Octokit;
+using System.Runtime.Serialization;
 
 namespace GitHub.Unity
 {
@@ -332,7 +333,8 @@ class GitHubRepository
         public string CloneUrl { get; set; }
     }
 
-    class ApiClientException : Exception
+    [Serializable]
+    public class ApiClientException : Exception
     {
         public ApiClientException()
         { }
@@ -342,8 +344,12 @@ public ApiClientException(string message) : base(message)
 
         public ApiClientException(string message, Exception innerException) : base(message, innerException)
         { }
+
+        protected ApiClientException(SerializationInfo info, StreamingContext context) : base(info, context)
+        { }
     }
 
+    [Serializable]
     class TokenUsernameMismatchException : ApiClientException
     {
         public string CachedUsername { get; }
@@ -354,11 +360,22 @@ public TokenUsernameMismatchException(string cachedUsername, string currentUsern
             CachedUsername = cachedUsername;
             CurrentUsername = currentUsername;
         }
+        protected TokenUsernameMismatchException(SerializationInfo info, StreamingContext context) : base(info, context)
+        { }
     }
 
+    [Serializable]
     class KeychainEmptyException : ApiClientException
     {
         public KeychainEmptyException()
         { }
+        public KeychainEmptyException(string message) : base(message)
+        { }
+
+        public KeychainEmptyException(string message, Exception innerException) : base(message, innerException)
+        { }
+
+        protected KeychainEmptyException(SerializationInfo info, StreamingContext context) : base(info, context)
+        { }
     }
 }

src/GitHub.Api/Authentication/Keychain.cs

@@ -10,6 +10,48 @@ public struct Connection
     {
         public UriString Host;
         public string Username;
+
+        public override int GetHashCode()
+        {
+            int hash = 17;
+            hash = hash * 23 + (Host?.GetHashCode() ?? 0);
+            hash = hash * 23 + (Username?.GetHashCode() ?? 0);
+            return hash;
+        }
+
+        public override bool Equals(object other)
+        {
+            if (other is Connection)
+                return Equals((Connection)other);
+            return false;
+        }
+
+        public bool Equals(Connection other)
+        {
+            return
+                object.Equals(Host, other.Host) &&
+                String.Equals(Username, other.Username)
+                ;
+        }
+
+        public static bool operator ==(Connection lhs, Connection rhs)
+        {
+            // If both are null, or both are same instance, return true.
+            if (ReferenceEquals(lhs, rhs))
+                return true;
+
+            // If one is null, but not both, return false.
+            if (((object)lhs == null) || ((object)rhs == null))
+                return false;
+
+            // Return true if the fields match:
+            return lhs.Equals(rhs);
+        }
+
+        public static bool operator !=(Connection lhs, Connection rhs)
+        {
+            return !(lhs == rhs);
+        }
     }
 
     class ConnectionCacheItem

src/GitHub.Api/Events/RepositoryWatcher.cs

@@ -149,7 +149,7 @@ public int CheckAndProcessEvents()
 
         private int ProcessEvents(Event[] fileEvents)
         {
-            Dictionary<EventType, List<EventData>> events = new Dictionary<EventType, List<EventData>>();
+            var events = new HashSet<EventType>();
             foreach (var fileEvent in fileEvents)
             {
                 if (!running)
@@ -177,90 +177,90 @@ private int ProcessEvents(Event[] fileEvents)
                 // handling events in .git/*
                 if (fileA.IsChildOf(paths.DotGitPath))
                 {
-                    if (!events.ContainsKey(EventType.ConfigChanged) && fileA.Equals(paths.DotGitConfig))
+                    if (!events.Contains(EventType.ConfigChanged) && fileA.Equals(paths.DotGitConfig))
                     {
-                        events.Add(EventType.ConfigChanged, null);
+                        events.Add(EventType.ConfigChanged);
                     }
-                    else if (!events.ContainsKey(EventType.HeadChanged) && fileA.Equals(paths.DotGitHead))
+                    else if (!events.Contains(EventType.HeadChanged) && fileA.Equals(paths.DotGitHead))
                     {
-                        events.Add(EventType.HeadChanged, null);
+                        events.Add(EventType.HeadChanged);
                     }
-                    else if (!events.ContainsKey(EventType.IndexChanged) && fileA.Equals(paths.DotGitIndex))
+                    else if (!events.Contains(EventType.IndexChanged) && fileA.Equals(paths.DotGitIndex))
                     {
-                        events.Add(EventType.IndexChanged, null);
+                        events.Add(EventType.IndexChanged);
                     }
-                    else if (!events.ContainsKey(EventType.RemoteBranchesChanged) && fileA.IsChildOf(paths.RemotesPath))
+                    else if (!events.Contains(EventType.RemoteBranchesChanged) && fileA.IsChildOf(paths.RemotesPath))
                     {
-                        events.Add(EventType.RemoteBranchesChanged, null);
+                        events.Add(EventType.RemoteBranchesChanged);
                     }
-                    else if (!events.ContainsKey(EventType.LocalBranchesChanged) && fileA.IsChildOf(paths.BranchesPath))
+                    else if (!events.Contains(EventType.LocalBranchesChanged) && fileA.IsChildOf(paths.BranchesPath))
                     {
-                        events.Add(EventType.LocalBranchesChanged, null);
+                        events.Add(EventType.LocalBranchesChanged);
                     }
-                    else if (!events.ContainsKey(EventType.RepositoryCommitted) && fileA.IsChildOf(paths.DotGitCommitEditMsg))
+                    else if (!events.Contains(EventType.RepositoryCommitted) && fileA.IsChildOf(paths.DotGitCommitEditMsg))
                     {
-                        events.Add(EventType.RepositoryCommitted, null);
+                        events.Add(EventType.RepositoryCommitted);
                     }
                 }
                 else
                 {
-                    if (events.ContainsKey(EventType.RepositoryChanged) || ignoredPaths.Any(ignoredPath => fileA.IsChildOf(ignoredPath)))
+                    if (events.Contains(EventType.RepositoryChanged) || ignoredPaths.Any(ignoredPath => fileA.IsChildOf(ignoredPath)))
                     {
                         continue;
                     }
-                    events.Add(EventType.RepositoryChanged, null);
+                    events.Add(EventType.RepositoryChanged);
                 }
             }
 
             return FireEvents(events);
         }
 
-        private int FireEvents(Dictionary<EventType, List<EventData>> events)
+        private int FireEvents(HashSet<EventType> events)
         {
             int eventsProcessed = 0;
-            if (events.ContainsKey(EventType.ConfigChanged))
+            if (events.Contains(EventType.ConfigChanged))
             {
                 Logger.Trace("ConfigChanged");
                 ConfigChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (events.ContainsKey(EventType.HeadChanged))
+            if (events.Contains(EventType.HeadChanged))
             {
                 Logger.Trace("HeadChanged");
                 HeadChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (events.ContainsKey(EventType.LocalBranchesChanged))
+            if (events.Contains(EventType.LocalBranchesChanged))
             {
                 Logger.Trace("LocalBranchesChanged");
                 LocalBranchesChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (events.ContainsKey(EventType.RemoteBranchesChanged))
+            if (events.Contains(EventType.RemoteBranchesChanged))
             {
                 Logger.Trace("RemoteBranchesChanged");
                 RemoteBranchesChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (events.ContainsKey(EventType.IndexChanged))
+            if (events.Contains(EventType.IndexChanged))
             {
                 Logger.Trace("IndexChanged");
                 IndexChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (events.ContainsKey(EventType.RepositoryChanged))
+            if (events.Contains(EventType.RepositoryChanged))
             {
                 Logger.Trace("RepositoryChanged");
                 RepositoryChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (events.ContainsKey(EventType.RepositoryCommitted))
+            if (events.Contains(EventType.RepositoryCommitted))
             {
                 Logger.Trace("RepositoryCommitted");
                 RepositoryCommitted?.Invoke();
@@ -306,11 +306,5 @@ private enum EventType
             RepositoryChanged,
             RepositoryCommitted
         }
-
-        private class EventData
-        {
-            public string Origin;
-            public string Branch;
-        }
     }
 }

src/GitHub.Api/Extensions/StringExtensions.cs

@@ -156,5 +156,45 @@ public struct StringResult
         public string Chunk;
         public int Start;
         public int End;
+
+        public override int GetHashCode()
+        {
+            int hash = 17;
+            hash = hash * 23 + (Chunk?.GetHashCode() ?? 0);
+            hash = hash * 23 + Start.GetHashCode();
+            hash = hash * 23 + End.GetHashCode();
+            return hash;
+        }
+
+        public override bool Equals(object other)
+        {
+            if (other is StringResult)
+                return Equals((StringResult)other);
+            return false;
+        }
+
+        public bool Equals(StringResult other)
+        {
+            return String.Equals(Chunk, other.Chunk) && Start == other.Start && End == other.End;
+        }
+
+        public static bool operator ==(StringResult lhs, StringResult rhs)
+        {
+            // If both are null, or both are same instance, return true.
+            if (ReferenceEquals(lhs, rhs))
+                return true;
+
+            // If one is null, but not both, return false.
+            if (((object)lhs == null) || ((object)rhs == null))
+                return false;
+
+            // Return true if the fields match:
+            return lhs.Equals(rhs);
+        }
+
+        public static bool operator !=(StringResult lhs, StringResult rhs)
+        {
+            return !(lhs == rhs);
+        }
     }
 }