Introducing IGameComparatorExemptions in order to waive checking version compatibility for select modules. (Take 2)

Core/CKAN-core.csproj

@@ -72,6 +72,8 @@
     <Compile Include="Types\CKANVersion.cs" />
     <Compile Include="Registry\IRegistryQuerier.cs" />
     <Compile Include="Types\ExportFileType.cs" />
+    <Compile Include="Types\GameComparator\GameComparatorExemptions.cs" />
+    <Compile Include="Types\GameComparator\IGameComparatorExemptions.cs" />
     <Compile Include="User.cs" />
     <Compile Include="Types\Version.cs" />
     <Compile Include="Meta.cs" />
@@ -119,7 +121,4 @@
     <None Include="packages.config" />
     <EmbeddedResource Include="builds.json" />
   </ItemGroup>
-  <ItemGroup />
-  <ItemGroup />
-  <ItemGroup />
-</Project>
+</Project>

Core/Types/GameComparator/GameComparatorExemptions.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CKAN
+{
+    public class GameComparatorExemptions : IGameComparatorExemptions
+    {
+        private struct CkanModuleProxy
+        {
+            public string Name { get; set; }
+            public string Identifier { get; set; }
+        }
+
+        private IEnumerable<CkanModuleProxy> _exemptions;
+
+
+        public GameComparatorExemptions(IEnumerable<CkanModule> exemptions = null)
+        {
+            if(exemptions != null)
+            {
+                _exemptions = exemptions.Select(ex => new CkanModuleProxy
+                {
+                    Name = ex.name,
+                    Identifier = String.IsNullOrEmpty(ex.identifier)
+                                    ? ex.name 
+                                    : ex.identifier
+                });
+            }
+            else
+            {
+                initDefaultGameExemptions();
+            }
+        }
+
+        public GameComparatorExemptions()
+        {
+            initDefaultGameExemptions();
+        }
+
+        private void initDefaultGameExemptions()
+        {
+            Func<string, CkanModuleProxy> exMod = 
+                name => new CkanModuleProxy { Name = name };
+            _exemptions = new List<CkanModuleProxy>
+            {
+                new CkanModuleProxy {Name= "CustomBarnKit" },
+                new CkanModuleProxy {Name= "ContractConfigurator" },
+                new CkanModuleProxy {Name= "ModuleManager" },
+                new CkanModuleProxy {Name= "Strategia" },
+            };
+        }
+
+        public bool IsExempt(CkanModule module)
+        {
+            _exemptions = _exemptions ?? new List<CkanModuleProxy>();
+            return _exemptions.Any(e => e.Name.ToLower() == module.name.ToLower()
+            || e.Name.ToLower() == module.identifier.ToLower());
+        }
+    }
+}

Core/Types/GameComparator/GrasGameComparator.cs

@@ -11,19 +11,21 @@ public class GrasGameComparator : BaseGameComparator
     {
         static readonly StrictGameComparator strict = new StrictGameComparator ();
         static readonly KspVersion v103 = KspVersion.Parse ("1.0.3");
+        private IGameComparatorExemptions _gameComparatorExemptions = new GameComparatorExemptions();
 
         public override bool Compatible (KspVersionCriteria gameVersionCriteria, CkanModule module)
         {
             // If it's strictly compatible, then it's compatible.
             if (strict.Compatible (gameVersionCriteria, module))
                 return true;
 
+            bool isExempt = _gameComparatorExemptions.IsExempt(module);
             // If we're in strict mode, and it's not strictly compatible, then it's
             // not compatible.
             if (module.ksp_version_strict)
-                return false;
+                return (false || isExempt);
 
-            return base.Compatible (gameVersionCriteria, module);
+            return (base.Compatible(gameVersionCriteria, module) || isExempt);
         }
 
         public override bool SingleVersionsCompatible (KspVersion gameVersion, CkanModule module){

Core/Types/GameComparator/IGameComparatorExemptions.cs

@@ -0,0 +1,11 @@
+namespace CKAN
+{
+    /// <summary>
+    /// Allows certain modules to pass as compatible even though
+    /// they might not be.
+    /// </summary>
+    public interface IGameComparatorExemptions
+    {
+        bool IsExempt(CkanModule module);
+    }
+}