diff --git a/.gitignore b/.gitignore index 9791284a..93d42729 100644 --- a/.gitignore +++ b/.gitignore @@ -58,7 +58,7 @@ _ReSharper* *.ncrunch* .*crunch*.local.xml -# Installshield output folder +# Installshield output folder [Ee]xpress # DocProject is a documentation generator add-in @@ -106,8 +106,8 @@ _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML - -ModuleManager.csproj ModuleManager.csproj.user -ModuleManager.*.dll \ No newline at end of file +ModuleManager.*.dll + +.vs* diff --git a/CopyLocalFalse.txt b/CopyLocalFalse.txt new file mode 100644 index 00000000..d5a69533 --- /dev/null +++ b/CopyLocalFalse.txt @@ -0,0 +1,2 @@ +Copy Local has been set to false for all dependencies. +Remark by Jan Van der Haegen: This file has been added because Nuget would installs packages to the solution instead of the project if there are only PowerShell scripts... (So yes: it's safe to remove this file!) \ No newline at end of file diff --git a/CustomConfigsManager.cs b/CustomConfigsManager.cs deleted file mode 100644 index 2532c43e..00000000 --- a/CustomConfigsManager.cs +++ /dev/null @@ -1,35 +0,0 @@ -using System; -using System.IO; -using UnityEngine; - -namespace ModuleManager -{ - [KSPAddon(KSPAddon.Startup.SpaceCentre, false)] - public class CustomConfigsManager : MonoBehaviour - { - internal void Start() - { - if (HighLogic.CurrentGame.Parameters.Career.TechTreeUrl != MMPatchLoader.techTreeFile && File.Exists(MMPatchLoader.techTreePath)) - { - log("Setting moddeed tech tree as the active one"); - HighLogic.CurrentGame.Parameters.Career.TechTreeUrl = MMPatchLoader.techTreeFile; - } - - if (PhysicsGlobals.PhysicsDatabaseFilename != MMPatchLoader.physicsFile && File.Exists(MMPatchLoader.physicsPath)) - { - log("Setting moddeed physics as the active one"); - - PhysicsGlobals.PhysicsDatabaseFilename = MMPatchLoader.physicsFile; - - if (!PhysicsGlobals.Instance.LoadDatabase()) - log("Something went wrong while setting the active physics config."); - } - } - - public static void log(String s) - { - print("[CustomConfigsManager] " + s); - } - - } -} diff --git a/ModuleManager.csproj b/ModuleManager.csproj deleted file mode 100644 index e4b787a9..00000000 --- a/ModuleManager.csproj +++ /dev/null @@ -1,64 +0,0 @@ - - - - Debug - AnyCPU - 10.0.0 - 2.0 - {02C8E3AF-69F9-4102-AB60-DD6DE60662D3} - Library - ModuleManager - ModuleManager - v3.5 - - - True - full - False - .. - DEBUG; - prompt - 4 - False - 5 - - - none - True - bin\Release\ - prompt - 4 - False - - - - - - - - - - False - False - - - - - False - False - - - - - - - - - - - - echo copying to "%25KSPDIR%25\GameData\" -copy "$(TargetPath)" "C:\Games\ksp-win_dev\GameData\" -del "C:\Games\ksp-win_dev\GameData\ModuleManager.ConfigCache" - - \ No newline at end of file diff --git a/ModuleManager.sln b/ModuleManager.sln index ce332b6d..ac8200bc 100644 --- a/ModuleManager.sln +++ b/ModuleManager.sln @@ -1,7 +1,15 @@  -Microsoft Visual Studio Solution File, Format Version 11.00 -# Visual Studio 2010 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ModuleManager", "ModuleManager.csproj", "{02C8E3AF-69F9-4102-AB60-DD6DE60662D3}" +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.26730.12 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ModuleManager", "ModuleManager\ModuleManager.csproj", "{02C8E3AF-69F9-4102-AB60-DD6DE60662D3}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ModuleManagerTests", "ModuleManagerTests\ModuleManagerTests.csproj", "{BC2A08C8-64EF-4823-A40B-8889C1CCFD75}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestUtils", "TestUtils\TestUtils.csproj", "{20EAAFE6-510D-4374-8D2F-6B52D0178E85}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestUtilsTests", "TestUtilsTests\TestUtilsTests.csproj", "{E695C11F-4217-4014-9B51-7232A654C205}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -13,6 +21,24 @@ Global {02C8E3AF-69F9-4102-AB60-DD6DE60662D3}.Debug|Any CPU.Build.0 = Debug|Any CPU {02C8E3AF-69F9-4102-AB60-DD6DE60662D3}.Release|Any CPU.ActiveCfg = Release|Any CPU {02C8E3AF-69F9-4102-AB60-DD6DE60662D3}.Release|Any CPU.Build.0 = Release|Any CPU + {BC2A08C8-64EF-4823-A40B-8889C1CCFD75}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BC2A08C8-64EF-4823-A40B-8889C1CCFD75}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BC2A08C8-64EF-4823-A40B-8889C1CCFD75}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BC2A08C8-64EF-4823-A40B-8889C1CCFD75}.Release|Any CPU.Build.0 = Release|Any CPU + {20EAAFE6-510D-4374-8D2F-6B52D0178E85}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {20EAAFE6-510D-4374-8D2F-6B52D0178E85}.Debug|Any CPU.Build.0 = Debug|Any CPU + {20EAAFE6-510D-4374-8D2F-6B52D0178E85}.Release|Any CPU.ActiveCfg = Release|Any CPU + {20EAAFE6-510D-4374-8D2F-6B52D0178E85}.Release|Any CPU.Build.0 = Release|Any CPU + {E695C11F-4217-4014-9B51-7232A654C205}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E695C11F-4217-4014-9B51-7232A654C205}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E695C11F-4217-4014-9B51-7232A654C205}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E695C11F-4217-4014-9B51-7232A654C205}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {4DCC10BA-6036-4DCF-A78B-086DF4487922} EndGlobalSection GlobalSection(MonoDevelopProperties) = preSolution StartupItem = ModuleManager.csproj diff --git a/ModuleManager/Cats/CatAnimator.cs b/ModuleManager/Cats/CatAnimator.cs new file mode 100644 index 00000000..7806d4aa --- /dev/null +++ b/ModuleManager/Cats/CatAnimator.cs @@ -0,0 +1,40 @@ +using System.Collections; +using System.Diagnostics.CodeAnalysis; +using UnityEngine; + +namespace ModuleManager.Cats +{ + class CatAnimator : MonoBehaviour + { + + public Sprite[] frames; + public float secFrame = 0.07f; + + private SpriteRenderer spriteRenderer; + private int spriteIdx; + + [SuppressMessage("CodeQuality", "IDE0051", Justification = "Called by Unity")] + void Start() + { + spriteRenderer = GetComponent(); + spriteRenderer.sortingOrder = 3; + StartCoroutine(Animate()); + } + + + IEnumerator Animate() + { + if (frames.Length == 0) + yield return null; + + WaitForSeconds yield = new WaitForSeconds(secFrame); + + while (true) + { + spriteIdx = (spriteIdx + 1) % frames.Length; + spriteRenderer.sprite = frames[spriteIdx]; + yield return yield; + } + } + } +} diff --git a/ModuleManager/Cats/CatManager.cs b/ModuleManager/Cats/CatManager.cs new file mode 100644 index 00000000..05f671d6 --- /dev/null +++ b/ModuleManager/Cats/CatManager.cs @@ -0,0 +1,115 @@ +using System; +using UnityEngine; + +namespace ModuleManager.Cats +{ + public static class CatManager + { + private static Sprite[] catFrames; + private static Texture2D rainbow; + private static int scale = 1; + + public static void LaunchCat() + { + InitCats(); + + GameObject cat = LaunchCat(scale); + cat.AddComponent(); + } + + public static void LaunchCats() + { + InitCats(); + + GameObject catSun = LaunchCat(scale); + CatOrbiter catSunOrbiter = catSun.AddComponent(); + catSunOrbiter.Init(null, 0); + + int cats = UnityEngine.Random.Range(6, 10); + for (int i = 0; i < cats; i++) + { + GameObject cat = LaunchCat(scale); + CatOrbiter catOrbiter = cat.AddComponent(); + catOrbiter.Init(catSunOrbiter, Screen.height * 0.5f); + + int moons = UnityEngine.Random.Range(0, 4); + + for (int j = 0; j < moons; j++) + { + GameObject catMoon = LaunchCat(scale); + CatOrbiter catMoonOrbiter = catMoon.AddComponent(); + catMoonOrbiter.Init(catOrbiter, Screen.height * 0.06f); + } + } + } + + private static void InitCats() + { + Texture2D[] tex = new Texture2D[12]; + for (int i = 0; i < tex.Length; i++) + { + tex[i] = new Texture2D(70, 42, TextureFormat.ARGB32, false); + } + tex[0].LoadImage(Properties.Resources.cat1); + tex[1].LoadImage(Properties.Resources.cat2); + tex[2].LoadImage(Properties.Resources.cat3); + tex[3].LoadImage(Properties.Resources.cat4); + tex[4].LoadImage(Properties.Resources.cat5); + tex[5].LoadImage(Properties.Resources.cat6); + tex[6].LoadImage(Properties.Resources.cat7); + tex[7].LoadImage(Properties.Resources.cat8); + tex[8].LoadImage(Properties.Resources.cat9); + tex[9].LoadImage(Properties.Resources.cat10); + tex[10].LoadImage(Properties.Resources.cat11); + tex[11].LoadImage(Properties.Resources.cat12); + + rainbow = new Texture2D(39, 36, TextureFormat.ARGB32, false); + rainbow.LoadImage(Properties.Resources.rainbow); + rainbow.Apply(); + + catFrames = new Sprite[12]; + + for (int i = 0; i < tex.Length; i++) + { + tex[i].Apply(); + catFrames[i] = Sprite.Create(tex[i], new Rect(0, 0, tex[i].width, tex[i].height), new Vector2(.5f, .5f)); + catFrames[i].name = "cat" + i; + } + + scale = 1; + if (Screen.height >= 1080) + scale *= 2; + if (Screen.height > 1440) + scale *= 3; + + Physics2D.gravity = Vector2.zero; + } + + private static GameObject LaunchCat(int scale) + { + GameObject cat = new GameObject("NyanCat"); + SpriteRenderer sr = cat.AddComponent(); + TrailRenderer trail = cat.AddComponent(); + CatAnimator catAnimator = cat.AddComponent(); + + sr.sprite = catFrames[0]; + + trail.material = new Material(Shader.Find("Legacy Shaders/Particles/Alpha Blended")); + + Debug.Log("material = " + trail.material); + trail.material.mainTexture = rainbow; + trail.time = 1.5f; + trail.startWidth = 0.6f * scale * rainbow.height; + + trail.endColor = Color.white.A(0.1f); + trail.colorGradient = new Gradient {alphaKeys = new GradientAlphaKey[3] { new GradientAlphaKey(1, 0), new GradientAlphaKey(1, 0.75f), new GradientAlphaKey(0.2f, 1) }}; + trail.Clear(); + cat.layer = LayerMask.NameToLayer("UI"); + + catAnimator.frames = catFrames; + + cat.transform.localScale = 70 * scale * Vector3.one; + return cat; + } + } +} diff --git a/ModuleManager/Cats/CatMover.cs b/ModuleManager/Cats/CatMover.cs new file mode 100644 index 00000000..d97a3f7c --- /dev/null +++ b/ModuleManager/Cats/CatMover.cs @@ -0,0 +1,81 @@ +using System.Diagnostics.CodeAnalysis; +using UnityEngine; + +namespace ModuleManager.Cats +{ + public class CatMover : MonoBehaviour + { + public Vector3 spos; + + public float vel = 5; + private float offsetY; + + public TrailRenderer trail; + private SpriteRenderer spriteRenderer; + + private int totalLenth = 100; + private float activePos = 0; + + public float scale = 2; + + private const float time = 5; + private const float trailTime = time / 4; + + private bool clearTrail = false; + + // Use this for initialization + [SuppressMessage("CodeQuality", "IDE0051", Justification = "Called by Unity")] + void Start() + { + trail = GetComponent(); + trail.sortingOrder = 2; + + spriteRenderer = GetComponent(); + + offsetY = Mathf.FloorToInt(0.2f * Screen.height); + + spos.z = -1; + + totalLenth = (int) (Screen.width / time * trail.time) + 150; + trail.time = trailTime; + trail.widthCurve = new AnimationCurve(new Keyframe(0, trail.startWidth ), new Keyframe(0.7f, trail.startWidth), new Keyframe(1, trail.startWidth * 0.9f)); + clearTrail = true; + } + + [SuppressMessage("CodeQuality", "IDE0051", Justification = "Called by Unity")] + void Update() + { + if (trail.time <= 0f) + { + trail.time = trailTime; + } + + activePos += ((Screen.width / time) * Time.deltaTime); + + if (activePos > (Screen.width + totalLenth)) + { + activePos = -spriteRenderer.sprite.rect.width; + clearTrail = true; + } + + float f = 2f * Mathf.PI * (activePos) / (Screen.width * 0.5f); + + float heightOffset = Mathf.Sin(f) * (spriteRenderer.sprite.rect.height * scale); + + spos.x = activePos; + spos.y = offsetY + heightOffset; + + transform.position = KSP.UI.UIMainCamera.Camera.ScreenToWorldPoint(spos); + transform.rotation = Quaternion.Euler(0, 0, Mathf.Cos(f) * 0.25f * Mathf.PI * Mathf.Rad2Deg); + + if (clearTrail) + { + trail.Clear(); + clearTrail = false; + } + + } + + + } +} diff --git a/ModuleManager/Cats/CatOrbiter.cs b/ModuleManager/Cats/CatOrbiter.cs new file mode 100644 index 00000000..34b1f6e8 --- /dev/null +++ b/ModuleManager/Cats/CatOrbiter.cs @@ -0,0 +1,139 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using KSP.UI; +using UnityEngine; +using Random = UnityEngine.Random; + +namespace ModuleManager.Cats +{ + class CatOrbiter : MonoBehaviour + { + private static readonly List orbiters = new List(); + + private static CatOrbiter sun; + + private double _mass; + public Rigidbody2D rb; + + private Vector2d pos; + private Vector2d vel; + private Vector2d force; + private float scale = 1; + + private const double G = 6.67408E-11; + + public double Mass + { + get { return _mass; } + set + { + _mass = value; + if (rb!=null) + rb.mass = (float)_mass; + } + } + + public void Init(CatOrbiter parent, float soi) + { + + TimingManager.FixedUpdateAdd(TimingManager.TimingStage.Earlyish, DoForces); + + orbiters.Add(this); + rb = gameObject.AddComponent(); + rb.isKinematic = true; + + if (orbiters.Count == 1) + { + sun = this; + Vector3 spos = new Vector3(Screen.width * 0.5f, Screen.height * 0.5f, -1); + transform.position = KSP.UI.UIMainCamera.Camera.ScreenToWorldPoint(spos); + Mass = 2E17; + pos.x = transform.position.x; + pos.y = transform.position.y; + } + else + { + Vector2 relativePos = Random.insideUnitCircle; + if (relativePos.magnitude < 0.2) + relativePos = relativePos.normalized * 0.3f; + Vector3 spos = UIMainCamera.Camera.WorldToScreenPoint(parent.transform.position) + (Vector3)(relativePos * soi); + spos.z = -1; + transform.position = UIMainCamera.Camera.ScreenToWorldPoint(spos); + + pos.x = transform.position.x; + pos.y = transform.position.y; + + //int scaleRange = 10; + // + //float factor = (1 + (scaleRange - 1) * Random.value); + // + //scale = parent.scale * factor / scaleRange; + scale = parent.scale * 0.6f; + + transform.localScale *= scale; + TrailRenderer trail = gameObject.GetComponent(); + trail.colorGradient = new Gradient() {alphaKeys = new GradientAlphaKey[3] { new GradientAlphaKey(1, 0), new GradientAlphaKey(1, 0.7f), new GradientAlphaKey(0, 1) }}; + trail.startWidth *= scale; + //trail.endWidth *= scale; + trail.widthCurve = new AnimationCurve(new Keyframe(0, trail.startWidth ), new Keyframe(0.7f, trail.startWidth), new Keyframe(1, trail.startWidth * 0.9f)); + + //Mass = factor * 2E16; + + Mass = parent.Mass * 0.025; + + Vector2d dist = parent.pos - pos; + double circularVel = Math.Sqrt(G * (Mass + parent.Mass) / dist.magnitude); + if (parent == sun) + circularVel *= Random.Range(0.9f, 1.1f); + Debug.Log("CatOrbiter " + circularVel.ToString("F3") + " " + Mass.ToString("F2") + " " + orbiters[0].Mass.ToString("F2") + " " + + dist.magnitude.ToString("F2")); + + Vector3d normal = (Random.value >= 0.3) ? Vector3d.back : Vector3d.forward; + + Vector3d vel3d = Vector3d.Cross(dist, normal).normalized * circularVel; + vel.x = parent.vel.x + vel3d.x; + vel.y = parent.vel.y + vel3d.y; + } + + rb.MovePosition(new Vector2((float)pos.x, (float)pos.y)); + } + + private void DoForces() + { + force = Vector2d.zero; + foreach (CatOrbiter cat in orbiters) + { + if (cat == this) + continue; + + // F = G * (m1 * m2) / r^2 + Vector2d dir = cat.pos - pos; + double f = G * (cat.Mass * Mass) / (dir.sqrMagnitude + 10); // +10 to avoid div/0 + force += (float)f * dir.normalized; + } + } + + [SuppressMessage("CodeQuality", "IDE0051", Justification = "Called by Unity")] + void OnDestroy() + { + orbiters.Remove(this); + TimingManager.FixedUpdateRemove(TimingManager.TimingStage.Earlyish, DoForces); + } + + [SuppressMessage("CodeQuality", "IDE0051", Justification = "Called by Unity")] + void FixedUpdate() + { + //if (this == sun) + // return; + + vel += Time.fixedDeltaTime * force / Mass; + pos += Time.fixedDeltaTime * vel; + + rb.MovePosition(new Vector2((float)pos.x, (float)pos.y)); + + double angle = Math.Atan2(vel.y, vel.x) * Mathf.Rad2Deg; + rb.MoveRotation((float)angle); + } + } +} diff --git a/ModuleManager/Collections/ArrayEnumerator.cs b/ModuleManager/Collections/ArrayEnumerator.cs new file mode 100644 index 00000000..775a35dd --- /dev/null +++ b/ModuleManager/Collections/ArrayEnumerator.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace ModuleManager.Collections +{ + public struct ArrayEnumerator : IEnumerator + { + private readonly T[] array; + private readonly int startIndex; + private readonly int length; + + private int index; + + public ArrayEnumerator(params T[] array) : this(array, 0) { } + + public ArrayEnumerator(T[] array, int startIndex) : this(array, startIndex, (array?.Length ?? -1) - startIndex) { } + + public ArrayEnumerator(T[] array, int startIndex, int length) + { + this.array = array ?? throw new ArgumentNullException(nameof(array)); + + if (startIndex < 0) + throw new ArgumentException($"must be non-negative (got {startIndex})", nameof(startIndex)); + if (startIndex > array.Length) + throw new ArgumentException( + $"must be less than or equal to array length (array length {array.Length}, startIndex {startIndex})", + nameof(startIndex) + ); + if (length < 0) + throw new ArgumentException($"must be non-negative (got {length})", nameof(length)); + if (startIndex + length > array.Length) + throw new ArgumentException( + $"must fit within the string (array length {array.Length}, startIndex {startIndex}, length {length})", + nameof(length) + ); + + this.startIndex = startIndex; + this.length = length; + index = startIndex - 1; + } + + public T Current => array[index]; + object IEnumerator.Current => Current; + + public void Dispose() { } + + public bool MoveNext() + { + index++; + return index < startIndex + length; + } + + public void Reset() + { + index = startIndex - 1; + } + } +} diff --git a/ModuleManager/Collections/ImmutableStack.cs b/ModuleManager/Collections/ImmutableStack.cs new file mode 100644 index 00000000..d710c423 --- /dev/null +++ b/ModuleManager/Collections/ImmutableStack.cs @@ -0,0 +1,82 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace ModuleManager.Collections +{ + public class ImmutableStack : IEnumerable + { + public struct Enumerator : IEnumerator + { + private readonly ImmutableStack head; + private ImmutableStack currentStack; + + public Enumerator(ImmutableStack stack) + { + head = stack; + currentStack = null; + } + + public T Current => currentStack.value; + object IEnumerator.Current => Current; + + public void Dispose() { } + + public bool MoveNext() + { + if (currentStack == null) + { + currentStack = head; + return true; + } + else if (!currentStack.IsRoot) + { + currentStack = currentStack.parent; + return true; + } + else + { + return false; + } + } + + public void Reset() => currentStack = null; + } + + public readonly T value; + public readonly ImmutableStack parent; + + public ImmutableStack(T value) + { + this.value = value; + } + + private ImmutableStack(T value, ImmutableStack parent) + { + this.value = value; + this.parent = parent; + } + + public bool IsRoot => parent == null; + public ImmutableStack Root => IsRoot? this : parent.Root; + + public int Depth => IsRoot ? 1 : parent.Depth + 1; + + public ImmutableStack Push(T newValue) + { + return new ImmutableStack(newValue, this); + } + + public ImmutableStack Pop() + { + if (IsRoot) throw new InvalidOperationException("Cannot pop from the root of a stack"); + return parent; + } + + public ImmutableStack ReplaceValue(T newValue) => new ImmutableStack(newValue, parent); + + public Enumerator GetEnumerator() => new Enumerator(this); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } +} diff --git a/ModuleManager/Collections/KeyValueCache.cs b/ModuleManager/Collections/KeyValueCache.cs new file mode 100644 index 00000000..0aaee61b --- /dev/null +++ b/ModuleManager/Collections/KeyValueCache.cs @@ -0,0 +1,29 @@ +using System; +using System.Collections.Generic; + +namespace ModuleManager.Collections +{ + public class KeyValueCache + { + private readonly Dictionary dict = new Dictionary(); + private readonly object lockObject = new object(); + + public TValue Fetch(TKey key, Func createValue) + { + if (createValue == null) throw new ArgumentNullException(nameof(createValue)); + lock(lockObject) + { + if (dict.TryGetValue(key, out TValue value)) + { + return value; + } + else + { + TValue newValue = createValue(); + dict.Add(key, newValue); + return newValue; + } + } + } + } +} diff --git a/ModuleManager/Collections/MessageQueue.cs b/ModuleManager/Collections/MessageQueue.cs new file mode 100644 index 00000000..b6038a77 --- /dev/null +++ b/ModuleManager/Collections/MessageQueue.cs @@ -0,0 +1,96 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace ModuleManager.Collections +{ + public interface IMessageQueue : IEnumerable + { + void Add(T value); + IMessageQueue TakeAll(); + } + + public class MessageQueue : IMessageQueue, IEnumerable + { + public sealed class Enumerator : IEnumerator + { + private readonly MessageQueue queue; + private Node current; + + public Enumerator(MessageQueue queue) + { + this.queue = queue; + } + + public T Current => current.value; + object IEnumerator.Current => Current; + + public void Dispose() { } + + public bool MoveNext() + { + if (current == null) + current = queue.head; + else + current = current.next; + + return current != null; + } + + public void Reset() + { + current = null; + } + } + + private class Node + { + public Node next; + public readonly T value; + + public Node(T value) + { + this.value = value; + } + } + + private readonly object lockObject = new object(); + private Node head; + private Node tail; + + public void Add(T value) + { + Node node = new Node(value); + lock (lockObject) + { + if (head == null) + { + head = node; + tail = node; + } + else + { + tail.next = node; + tail = node; + } + } + } + + public IMessageQueue TakeAll() + { + MessageQueue queue = new MessageQueue(); + lock(lockObject) + { + queue.head = head; + queue.tail = tail; + head = null; + tail = null; + } + return queue; + } + + public Enumerator GetEnumerator() => new Enumerator(this); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } +} diff --git a/ModuleManager/Command.cs b/ModuleManager/Command.cs new file mode 100644 index 00000000..5e7dde49 --- /dev/null +++ b/ModuleManager/Command.cs @@ -0,0 +1,25 @@ +using System; + +namespace ModuleManager +{ + public enum Command + { + Insert, + + Delete, + + Edit, + + Replace, + + Copy, + + Rename, + + Paste, + + Special, + + Create + } +} diff --git a/ModuleManager/CommandParser.cs b/ModuleManager/CommandParser.cs new file mode 100644 index 00000000..89029b77 --- /dev/null +++ b/ModuleManager/CommandParser.cs @@ -0,0 +1,59 @@ +using System; + +namespace ModuleManager +{ + public static class CommandParser + { + public static Command Parse(string name, out string valueName) + { + if (name.Length == 0) + { + valueName = string.Empty; + return Command.Insert; + } + Command ret; + switch (name[0]) + { + case '@': + ret = Command.Edit; + break; + + case '%': + ret = Command.Replace; + break; + + case '-': + case '!': + ret = Command.Delete; + break; + + case '+': + case '$': + ret = Command.Copy; + break; + + case '|': + ret = Command.Rename; + break; + + case '#': + ret = Command.Paste; + break; + + case '*': + ret = Command.Special; + break; + + case '&': + ret = Command.Create; + break; + + default: + valueName = name; + return Command.Insert; + } + valueName = name.Substring(1); + return ret; + } + } +} diff --git a/ModuleManager/CustomConfigsManager.cs b/ModuleManager/CustomConfigsManager.cs new file mode 100644 index 00000000..d7444363 --- /dev/null +++ b/ModuleManager/CustomConfigsManager.cs @@ -0,0 +1,27 @@ +using System; +using System.IO; +using UnityEngine; + +using static ModuleManager.FilePathRepository; + +namespace ModuleManager +{ + [KSPAddon(KSPAddon.Startup.SpaceCentre, false)] + public class CustomConfigsManager : MonoBehaviour + { + internal void Start() + { + if (HighLogic.CurrentGame.Parameters.Career.TechTreeUrl != techTreeFile && File.Exists(techTreePath)) + { + Log("Setting modded tech tree as the active one"); + HighLogic.CurrentGame.Parameters.Career.TechTreeUrl = techTreeFile; + } + } + + public static void Log(String s) + { + print("[CustomConfigsManager] " + s); + } + + } +} diff --git a/ModuleManager/ExceptionIntercept/InterceptLogHandler.cs b/ModuleManager/ExceptionIntercept/InterceptLogHandler.cs new file mode 100644 index 00000000..471b1fa8 --- /dev/null +++ b/ModuleManager/ExceptionIntercept/InterceptLogHandler.cs @@ -0,0 +1,64 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Reflection; +using UnityEngine; +using Object = UnityEngine.Object; + +namespace ModuleManager.UnityLogHandle +{ + class InterceptLogHandler : ILogHandler + { + private readonly ILogHandler baseLogHandler; + private readonly List brokenAssemblies = new List(); + private readonly int gamePathLength; + + public static string Warnings { get; private set; } = ""; + + public InterceptLogHandler(ILogHandler baseLogHandler) + { + this.baseLogHandler = baseLogHandler ?? throw new ArgumentNullException(nameof(baseLogHandler)); + gamePathLength = Path.GetFullPath(KSPUtil.ApplicationRootPath).Length; + } + + public void LogFormat(LogType logType, Object context, string format, params object[] args) + { + baseLogHandler.LogFormat(logType, context, format, args); + } + + public void LogException(Exception exception, Object context) + { + baseLogHandler.LogException(exception, context); + + if (exception is ReflectionTypeLoadException ex) + { + string message = "Intercepted a ReflectionTypeLoadException. List of broken DLLs:\n"; + try + { + var assemblies = ex.Types.Where(x => x != null).Select(x => x.Assembly).Distinct(); + foreach (Assembly assembly in assemblies) + { + if (Warnings == "") + { + Warnings = "Mod(s) DLL that are not compatible with this version of KSP\n"; + } + string modInfo = assembly.GetName().Name + " " + assembly.GetName().Version + " " + + assembly.Location.Remove(0, gamePathLength) + "\n"; + if (!brokenAssemblies.Contains(assembly)) + { + brokenAssemblies.Add(assembly); + Warnings += modInfo; + } + message += modInfo; + } + } + catch (Exception e) + { + message += "Exception " + e.GetType().Name + " while handling the exception..."; + } + ModuleManager.Log(message); + } + } + } +} diff --git a/ModuleManager/Extensions/ByteArrayExtensions.cs b/ModuleManager/Extensions/ByteArrayExtensions.cs new file mode 100644 index 00000000..520393df --- /dev/null +++ b/ModuleManager/Extensions/ByteArrayExtensions.cs @@ -0,0 +1,29 @@ +using System; + +namespace ModuleManager.Extensions +{ + public static class ByteArrayExtensions + { + public static string ToHex(this byte[] data) + { + if (data == null) throw new ArgumentNullException(nameof(data)); + char[] result = new char[data.Length * 2]; + + for (int i = 0; i < data.Length; i++) + { + result[i * 2] = GetHexValue(data[i] / 16); + result[i * 2 + 1] = GetHexValue(data[i] % 16); + } + + return new string(result); + } + + private static char GetHexValue(int i) + { + if (i < 10) + return (char)(i + '0'); + else + return (char)(i - 10 + 'a'); + } + } +} diff --git a/ModuleManager/Extensions/ConfigNodeExtensions.cs b/ModuleManager/Extensions/ConfigNodeExtensions.cs new file mode 100644 index 00000000..9f552566 --- /dev/null +++ b/ModuleManager/Extensions/ConfigNodeExtensions.cs @@ -0,0 +1,107 @@ +using System; +using System.Text; + +namespace ModuleManager.Extensions +{ + public static class ConfigNodeExtensions + { + public static void ShallowCopyFrom(this ConfigNode toNode, ConfigNode fromeNode) + { + toNode.ClearData(); + foreach (ConfigNode.Value value in fromeNode.values) + toNode.values.Add(value); + foreach (ConfigNode node in fromeNode.nodes) + toNode.nodes.Add(node); + } + + // KSP implementation of ConfigNode.CreateCopy breaks with badly formed nodes (nodes with a blank name) + public static ConfigNode DeepCopy(this ConfigNode from) + { + ConfigNode to = new ConfigNode(from.name); + foreach (ConfigNode.Value value in from.values) + to.AddValueSafe(value.name, value.value); + foreach (ConfigNode node in from.nodes) + { + ConfigNode newNode = DeepCopy(node); + to.nodes.Add(newNode); + } + return to; + } + + public static void PrettyPrint(this ConfigNode node, ref StringBuilder sb, string indent) + { + if (sb == null) throw new ArgumentNullException(nameof(sb)); + if (indent == null) indent = string.Empty; + if (node == null) + { + sb.Append(indent + "\n"); + return; + } + sb.AppendFormat("{0}{1}\n{2}{{\n", indent, node.name ?? "", indent); + string newindent = indent + " "; + if (node.values == null) + { + sb.AppendFormat("{0}\n", newindent); + } + else + { + foreach (ConfigNode.Value value in node.values) + { + if (value == null) + sb.AppendFormat("{0}\n", newindent); + else + sb.AppendFormat("{0}{1} = {2}\n", newindent, value.name ?? "", value.value ?? ""); + } + } + + if (node.nodes == null) + { + sb.AppendFormat("{0}\n", newindent); + } + else + { + foreach (ConfigNode subnode in node.nodes) + { + subnode.PrettyPrint(ref sb, newindent); + } + } + + sb.AppendFormat("{0}}}\n", indent); + } + + public static void AddValueSafe(this ConfigNode node, string name, string value) + { + node.values.Add(new ConfigNode.Value(name, value)); + } + + public static void EscapeValuesRecursive(this ConfigNode theNode) + { + foreach (ConfigNode subNode in theNode.nodes) + { + subNode.EscapeValuesRecursive(); + } + + foreach (ConfigNode.Value value in theNode.values) + { + value.value = value.value.Replace("\n", "\\n"); + value.value = value.value.Replace("\r", "\\r"); + value.value = value.value.Replace("\t", "\\t"); + } + } + + public static void UnescapeValuesRecursive(this ConfigNode theNode) + { + foreach (ConfigNode subNode in theNode.nodes) + { + subNode.UnescapeValuesRecursive(); + } + + foreach (ConfigNode.Value value in theNode.values) + { + value.value = value.value.Replace("\\n", "\n"); + value.value = value.value.Replace("\\r", "\r"); + value.value = value.value.Replace("\\t", "\t"); + } + } + } +} diff --git a/ModuleManager/Extensions/IBasicLoggerExtensions.cs b/ModuleManager/Extensions/IBasicLoggerExtensions.cs new file mode 100644 index 00000000..9fd29be3 --- /dev/null +++ b/ModuleManager/Extensions/IBasicLoggerExtensions.cs @@ -0,0 +1,26 @@ +using System; +using UnityEngine; +using ModuleManager.Logging; + +namespace ModuleManager.Extensions +{ + public static class IBasicLoggerExtensions + { + public static void Info(this IBasicLogger logger, string message) => logger.Log(new LogMessage(LogType.Log, message)); + public static void Warning(this IBasicLogger logger, string message) => logger.Log(new LogMessage(LogType.Warning, message)); + public static void Error(this IBasicLogger logger, string message) => logger.Log(new LogMessage(LogType.Error, message)); + + public static void Exception(this IBasicLogger logger, Exception exception) + { + if (exception == null) throw new ArgumentNullException(nameof(exception)); + logger.Log(new LogMessage(LogType.Exception, exception.ToString())); + } + + public static void Exception(this IBasicLogger logger, string message, Exception exception) + { + if (message == null) throw new ArgumentNullException(nameof(message)); + if (exception == null) throw new ArgumentNullException(nameof(exception)); + logger.Log(new LogMessage(LogType.Exception, message + ": " + exception.ToString())); + } + } +} diff --git a/ModuleManager/Extensions/NodeStackExtensions.cs b/ModuleManager/Extensions/NodeStackExtensions.cs new file mode 100644 index 00000000..c6357dca --- /dev/null +++ b/ModuleManager/Extensions/NodeStackExtensions.cs @@ -0,0 +1,25 @@ +using System; +using System.Linq; +using System.Text; +using NodeStack = ModuleManager.Collections.ImmutableStack; + +namespace ModuleManager.Extensions +{ + public static class NodeStackExtensions + { + public static string GetPath(this NodeStack stack) + { + int length = stack.Sum(node => node.name.Length) + stack.Depth - 1; + StringBuilder sb = new StringBuilder(length); + + foreach (ConfigNode node in stack) + { + string nodeName = node.name; + sb.Insert(0, node.name); + if (sb.Length < sb.Capacity) sb.Insert(0, '/'); + } + + return sb.ToString(); + } + } +} diff --git a/ModuleManager/Extensions/StringExtensions.cs b/ModuleManager/Extensions/StringExtensions.cs new file mode 100644 index 00000000..634fab7a --- /dev/null +++ b/ModuleManager/Extensions/StringExtensions.cs @@ -0,0 +1,37 @@ +using System; +using System.Text.RegularExpressions; + +namespace ModuleManager.Extensions +{ + public static class StringExtensions + { + public static bool IsBracketBalanced(this string s) + { + int level = 0; + foreach (char c in s) + { + if (c == '[') level++; + else if (c == ']') level--; + + if (level < 0) return false; + } + return level == 0; + } + + private static readonly Regex whitespaceRegex = new Regex(@"\s+"); + + public static string RemoveWS(this string withWhite) + { + return whitespaceRegex.Replace(withWhite, ""); + } + + public static bool Contains(this string str, string value, out int index) + { + if (str == null) throw new ArgumentNullException(nameof(str)); + if (value == null) throw new ArgumentNullException(nameof(value)); + + index = str.IndexOf(value, StringComparison.CurrentCultureIgnoreCase); + return index != -1; + } + } +} diff --git a/ModuleManager/Extensions/UrlConfigExtensions.cs b/ModuleManager/Extensions/UrlConfigExtensions.cs new file mode 100644 index 00000000..d5ce9fbe --- /dev/null +++ b/ModuleManager/Extensions/UrlConfigExtensions.cs @@ -0,0 +1,60 @@ +using System; +using System.Text; + +namespace ModuleManager.Extensions +{ + public static class UrlConfigExtensions + { + public static string SafeUrl(this UrlDir.UrlConfig url) + { + if (url == null) return ""; + + string nodeName; + + if (!string.IsNullOrEmpty(url.type?.Trim())) + { + nodeName = url.type; + } + else if (url.type == null) + { + nodeName = ""; + } + else + { + nodeName = ""; + } + + string parentUrl = null; + + if (url.parent != null) + { + try + { + parentUrl = url.parent.url; + } + catch + { + parentUrl = ""; + } + } + + if (parentUrl == null) + return nodeName; + else + return parentUrl + "/" + nodeName; + } + + public static string PrettyPrint(this UrlDir.UrlConfig config) + { + if (config == null) return ""; + + StringBuilder sb = new StringBuilder(); + + sb.Append(config.SafeUrl()); + sb.Append('\n'); + config.config.PrettyPrint(ref sb, " "); + + return sb.ToString(); + } + } +} diff --git a/ModuleManager/Extensions/UrlDirExtensions.cs b/ModuleManager/Extensions/UrlDirExtensions.cs new file mode 100644 index 00000000..3a57bf6a --- /dev/null +++ b/ModuleManager/Extensions/UrlDirExtensions.cs @@ -0,0 +1,43 @@ +using System; +using System.Linq; + +namespace ModuleManager.Extensions +{ + public static class UrlDirExtensions + { + public static UrlDir.UrlFile Find(this UrlDir urlDir, string url) + { + if (urlDir == null) throw new ArgumentNullException(nameof(urlDir)); + if (url == null) throw new ArgumentNullException(nameof(url)); + string[] splits = url.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries); + + UrlDir currentDir = urlDir; + + for (int i = 0; i < splits.Length - 1; i++) + { + currentDir = currentDir.children.FirstOrDefault(subDir => subDir.name == splits[i]); + if (currentDir == null) return null; + } + + string fileName = splits[splits.Length - 1]; + string fileExtension = null; + + int idx = fileName.LastIndexOf('.'); + + if (idx > -1) + { + fileExtension = fileName.Substring(idx + 1); + fileName = fileName.Substring(0, idx); + } + + foreach (UrlDir.UrlFile file in currentDir.files) + { + if (file.name != fileName) continue; + if (fileExtension != null && fileExtension != file.fileExtension) continue; + return file; + } + + return null; + } + } +} diff --git a/ModuleManager/Extensions/UrlFileExtensions.cs b/ModuleManager/Extensions/UrlFileExtensions.cs new file mode 100644 index 00000000..3d203b24 --- /dev/null +++ b/ModuleManager/Extensions/UrlFileExtensions.cs @@ -0,0 +1,16 @@ +using System; + +namespace ModuleManager.Extensions +{ + public static class UrlFileExtensions + { + public static string GetUrlWithExtension(this UrlDir.UrlFile urlFile) + { + return $"{urlFile.url}.{urlFile.fileExtension}"; + } + public static string GetNameWithExtension(this UrlDir.UrlFile urlFile) + { + return $"{urlFile.name}.{urlFile.fileExtension}"; + } + } +} diff --git a/ModuleManager/FatalErrorHandler.cs b/ModuleManager/FatalErrorHandler.cs new file mode 100644 index 00000000..06bf686e --- /dev/null +++ b/ModuleManager/FatalErrorHandler.cs @@ -0,0 +1,38 @@ +using System; +using UnityEngine; + +namespace ModuleManager +{ + public static class FatalErrorHandler + { + public static void HandleFatalError(string message) + { + try + { + PopupDialog.SpawnPopupDialog(new Vector2(0.5f, 0.5f), + new Vector2(0.5f, 0.5f), + new MultiOptionDialog( + "ModuleManagerFatalError", + $"ModuleManager has encountered a fatal error and KSP needs to close.\n\n{message}\n\nPlease see KSP's log for addtional details", + "ModuleManager - Fatal Error", + HighLogic.UISkin, + new Rect(0.5f, 0.5f, 500f, 60f), + new DialogGUIFlexibleSpace(), + new DialogGUIHorizontalLayout( + new DialogGUIFlexibleSpace(), + new DialogGUIButton("Quit", Application.Quit, 140.0f, 30.0f, true), + new DialogGUIFlexibleSpace() + ) + ), + true, + HighLogic.UISkin); + } + catch(Exception ex) + { + Debug.LogError("Exception while trying to create the fatal exception dialog"); + Debug.LogException(ex); + Application.Quit(); + } + } + } +} diff --git a/ModuleManager/FilePathRepository.cs b/ModuleManager/FilePathRepository.cs new file mode 100644 index 00000000..0d1448d7 --- /dev/null +++ b/ModuleManager/FilePathRepository.cs @@ -0,0 +1,26 @@ +using System; +using System.IO; + +namespace ModuleManager +{ + internal static class FilePathRepository + { + internal static readonly string normalizedRootPath = Path.GetFullPath(KSPUtil.ApplicationRootPath); + internal static readonly string cachePath = Path.Combine(normalizedRootPath, "GameData", "ModuleManager.ConfigCache"); + + internal static readonly string techTreeFile = Path.Combine("GameData", "ModuleManager.TechTree"); + internal static readonly string techTreePath = Path.Combine(normalizedRootPath, techTreeFile); + + internal static readonly string physicsFile = Path.Combine("GameData", "ModuleManager.Physics"); + internal static readonly string physicsPath = Path.Combine(normalizedRootPath, physicsFile); + internal static readonly string defaultPhysicsPath = Path.Combine(normalizedRootPath, "Physics.cfg"); + + internal static readonly string partDatabasePath = Path.Combine(normalizedRootPath, "PartDatabase.cfg"); + + internal static readonly string shaPath = Path.Combine(normalizedRootPath, "GameData", "ModuleManager.ConfigSHA"); + + internal static readonly string logsDirPath = Path.Combine(normalizedRootPath, "Logs", "ModuleManager"); + internal static readonly string logPath = Path.Combine(logsDirPath, "ModuleManager.log"); + internal static readonly string patchLogPath = Path.Combine(logsDirPath, "MMPatch.log"); + } +} diff --git a/ModuleManager/Fix16.cs b/ModuleManager/Fix16.cs new file mode 100644 index 00000000..b567eb56 --- /dev/null +++ b/ModuleManager/Fix16.cs @@ -0,0 +1,83 @@ +using System.Collections; +using System.Diagnostics.CodeAnalysis; + +namespace ModuleManager +{ + class Fix16 : LoadingSystem + { + [SuppressMessage("CodeQuality", "IDE0051", Justification = "Called by Unity")] + private void Awake() + { + if (Instance != null) + { + DestroyImmediate(this); + return; + } + + Instance = this; + DontDestroyOnLoad(gameObject); + } + + private static Fix16 Instance { get; set; } + + private bool ready; + + private int count; + + private int current; + + private const int yieldStep = 20; + + public override bool IsReady() + { + return ready; + } + + public override string ProgressTitle() + { + return "Fix 1.6.0 " + current + "/" + count; + } + + public override float ProgressFraction() + { + return (float) current / count; + } + + public override void StartLoad() + { + ready = false; + + count = PartLoader.LoadedPartsList.Count; + + StartCoroutine(DoFix()); + } + + private IEnumerator DoFix() + { + int yieldCounter = 0; + for (current = 0; current < count; current++) + { + AvailablePart avp = PartLoader.LoadedPartsList[current]; + if (avp.partPrefab.dragModel == Part.DragModel.CUBE && !avp.partPrefab.DragCubes.Procedural && + !avp.partPrefab.DragCubes.None && avp.partPrefab.DragCubes.Cubes.Count == 0) + { + DragCubeSystem.Instance.LoadDragCubes(avp.partPrefab); + } + + if (yieldCounter++ >= yieldStep) + { + yieldCounter = 0; + yield return null; + } + } + + ready = true; + yield return null; + } + + public override float LoadWeight() + { + return 0.1f; + } + } +} diff --git a/ModuleManager/Logging/IBasicLogger.cs b/ModuleManager/Logging/IBasicLogger.cs new file mode 100644 index 00000000..25cd9367 --- /dev/null +++ b/ModuleManager/Logging/IBasicLogger.cs @@ -0,0 +1,10 @@ +using System; + +namespace ModuleManager.Logging +{ + // Stripped down version of UnityEngine.ILogger + public interface IBasicLogger + { + void Log(ILogMessage message); + } +} diff --git a/ModuleManager/Logging/ILogMessage.cs b/ModuleManager/Logging/ILogMessage.cs new file mode 100644 index 00000000..bf85f488 --- /dev/null +++ b/ModuleManager/Logging/ILogMessage.cs @@ -0,0 +1,13 @@ +using System; +using UnityEngine; + +namespace ModuleManager.Logging +{ + public interface ILogMessage + { + LogType LogType { get; } + DateTime Timestamp { get; } + string Message { get; } + string ToLogString(); + } +} diff --git a/ModuleManager/Logging/LogMessage.cs b/ModuleManager/Logging/LogMessage.cs new file mode 100644 index 00000000..c6554aaf --- /dev/null +++ b/ModuleManager/Logging/LogMessage.cs @@ -0,0 +1,53 @@ +using System; +using UnityEngine; + +namespace ModuleManager.Logging +{ + public class LogMessage : ILogMessage + { + private const string DATETIME_FORMAT_STRING = "HH:mm:ss.fff"; + + public LogType LogType { get; } + public DateTime Timestamp { get; } + public string Message { get; } + + public LogMessage(LogType logType, string message) + { + LogType = logType; + Timestamp = DateTime.Now; + Message = message ?? throw new ArgumentNullException(nameof(message)); + } + + public LogMessage(ILogMessage logMessage, string newMessage) + { + if (logMessage == null) throw new ArgumentNullException(nameof(logMessage)); + LogType = logMessage.LogType; + Timestamp = logMessage.Timestamp; + Message = newMessage ?? throw new ArgumentNullException(nameof(newMessage)); + } + + public string ToLogString() + { + string prefix; + if (LogType == LogType.Log) + prefix = "LOG"; + else if (LogType == LogType.Warning) + prefix = "WRN"; + else if (LogType == LogType.Error) + prefix = "ERR"; + else if (LogType == LogType.Assert) + prefix = "AST"; + else if (LogType == LogType.Exception) + prefix = "EXC"; + else + prefix = "???"; + + return $"[{prefix} {Timestamp.ToString(DATETIME_FORMAT_STRING)}] {Message}"; + } + + public override string ToString() + { + return $"[{GetType().FullName} LogType={LogType} Message={Message}]"; + } + } +} diff --git a/ModuleManager/Logging/LogSplitter.cs b/ModuleManager/Logging/LogSplitter.cs new file mode 100644 index 00000000..b1d2c89f --- /dev/null +++ b/ModuleManager/Logging/LogSplitter.cs @@ -0,0 +1,23 @@ +using System; + +namespace ModuleManager.Logging +{ + public class LogSplitter : IBasicLogger + { + private readonly IBasicLogger logger1; + private readonly IBasicLogger logger2; + + public LogSplitter(IBasicLogger logger1, IBasicLogger logger2) + { + this.logger1 = logger1 ?? throw new ArgumentNullException(nameof(logger1)); + this.logger2 = logger2 ?? throw new ArgumentNullException(nameof(logger2)); + } + + public void Log(ILogMessage message) + { + if (message == null) throw new ArgumentNullException(nameof(message)); + logger1.Log(message); + logger2.Log(message); + } + } +} diff --git a/ModuleManager/Logging/PrefixLogger.cs b/ModuleManager/Logging/PrefixLogger.cs new file mode 100644 index 00000000..410473fa --- /dev/null +++ b/ModuleManager/Logging/PrefixLogger.cs @@ -0,0 +1,23 @@ +using System; + +namespace ModuleManager.Logging +{ + public class PrefixLogger : IBasicLogger + { + private readonly string prefix; + private readonly IBasicLogger logger; + + public PrefixLogger(string prefix, IBasicLogger logger) + { + if (string.IsNullOrEmpty(prefix)) throw new ArgumentNullException(nameof(prefix)); + this.prefix = $"[{prefix}] "; + this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public void Log(ILogMessage message) + { + if (message == null) throw new ArgumentNullException(nameof(message)); + logger.Log(new LogMessage(message, prefix + message.Message)); + } + } +} diff --git a/ModuleManager/Logging/QueueLogRunner.cs b/ModuleManager/Logging/QueueLogRunner.cs new file mode 100644 index 00000000..f78cf611 --- /dev/null +++ b/ModuleManager/Logging/QueueLogRunner.cs @@ -0,0 +1,68 @@ +using System; +using System.IO; + +using ModuleManager.Collections; + +namespace ModuleManager.Logging +{ + public class QueueLogRunner + { + private enum State + { + Initialized, + Running, + StopRequested, + Stopped, + } + + private State state = State.Initialized; + private readonly IMessageQueue logQueue; + private readonly long timeToWaitForLogsMs; + + public QueueLogRunner(IMessageQueue logQueue, long timeToWaitForLogsMs = 50) + { + this.logQueue = logQueue ?? throw new ArgumentNullException(nameof(logQueue)); + if (timeToWaitForLogsMs < 0) throw new ArgumentException("must be non-negative", nameof(timeToWaitForLogsMs)); + this.timeToWaitForLogsMs = timeToWaitForLogsMs; + } + + public void RequestStop() + { + if (state == State.StopRequested || state == State.Stopped) return; + if (state != State.Running) throw new InvalidOperationException($"Cannot request stop from {state} state"); + state = State.StopRequested; + } + + public void Run(IBasicLogger logger) + { + if (state != State.Initialized) throw new InvalidOperationException($"Cannot run from {state} state"); + if (logger == null) throw new ArgumentNullException(nameof(logger)); + state = State.Running; + + System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch(); + + while (state == State.Running) + { + stopwatch.Start(); + + foreach (ILogMessage message in logQueue.TakeAll()) + { + logger.Log(message); + } + + long timeRemaining = timeToWaitForLogsMs - stopwatch.ElapsedMilliseconds; + if (timeRemaining > 0) + System.Threading.Thread.Sleep((int)timeRemaining); + + stopwatch.Reset(); + } + + foreach (ILogMessage message in logQueue.TakeAll()) + { + logger.Log(message); + } + + state = State.Stopped; + } + } +} diff --git a/ModuleManager/Logging/QueueLogger.cs b/ModuleManager/Logging/QueueLogger.cs new file mode 100644 index 00000000..b7cd288a --- /dev/null +++ b/ModuleManager/Logging/QueueLogger.cs @@ -0,0 +1,21 @@ +using System; +using ModuleManager.Collections; + +namespace ModuleManager.Logging +{ + public class QueueLogger : IBasicLogger + { + private readonly IMessageQueue queue; + + public QueueLogger(IMessageQueue queue) + { + this.queue = queue ?? throw new ArgumentNullException(nameof(queue)); + } + + public void Log(ILogMessage message) + { + if (message == null) throw new ArgumentNullException(nameof(message)); + queue.Add(message); + } + } +} diff --git a/ModuleManager/Logging/StreamLogger.cs b/ModuleManager/Logging/StreamLogger.cs new file mode 100644 index 00000000..d020f64c --- /dev/null +++ b/ModuleManager/Logging/StreamLogger.cs @@ -0,0 +1,32 @@ +using System; +using System.IO; + +namespace ModuleManager.Logging +{ + public sealed class StreamLogger : IBasicLogger, IDisposable + { + private readonly StreamWriter streamWriter; + private bool disposed = false; + + public StreamLogger(Stream stream) + { + streamWriter = new StreamWriter(stream); + } + + public void Log(ILogMessage message) + { + if (disposed) throw new InvalidOperationException("Object has already been disposed"); + if (message == null) throw new ArgumentNullException(nameof(message)); + + streamWriter.WriteLine(message.ToLogString()); + } + + public void Dispose() + { + // Flushes and closes the StreamWriter and the underlying stream + streamWriter.Close(); + + disposed = true; + } + } +} diff --git a/ModuleManager/Logging/UnityLogger.cs b/ModuleManager/Logging/UnityLogger.cs new file mode 100644 index 00000000..d51063c4 --- /dev/null +++ b/ModuleManager/Logging/UnityLogger.cs @@ -0,0 +1,21 @@ +using System; +using UnityEngine; + +namespace ModuleManager.Logging +{ + public class UnityLogger : IBasicLogger + { + private readonly ILogger logger; + + public UnityLogger(ILogger logger) + { + this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public void Log(ILogMessage message) + { + if (message == null) throw new ArgumentNullException(nameof(message)); + logger.Log(message.LogType, message.Message); + } + } +} diff --git a/ModuleManager/MMPatchLoader.cs b/ModuleManager/MMPatchLoader.cs new file mode 100644 index 00000000..5278758b --- /dev/null +++ b/ModuleManager/MMPatchLoader.cs @@ -0,0 +1,1777 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Text.RegularExpressions; + +using ModuleManager.Collections; +using ModuleManager.Logging; +using ModuleManager.Extensions; +using ModuleManager.Threading; +using ModuleManager.Tags; +using ModuleManager.Patches; +using ModuleManager.Progress; +using NodeStack = ModuleManager.Collections.ImmutableStack; + +using static ModuleManager.FilePathRepository; + +namespace ModuleManager +{ + public class MMPatchLoader + { + private const string PHYSICS_NODE_NAME = "PHYSICSGLOBALS"; + private const string TECH_TREE_NODE_NAME = "TechTree"; + + public string status = ""; + + public string errors = ""; + + public static bool keepPartDB = false; + + private static readonly KeyValueCache regexCache = new KeyValueCache(); + + private string configSha; + private readonly Dictionary filesSha = new Dictionary(); + + private const int STATUS_UPDATE_INVERVAL_MS = 33; + + private readonly IEnumerable modsAddedByAssemblies; + private readonly IBasicLogger logger; + + public static void AddPostPatchCallback(ModuleManagerPostPatchCallback callback) + { + PostPatchLoader.AddPostPatchCallback(callback); + } + + public MMPatchLoader(IEnumerable modsAddedByAssemblies, IBasicLogger logger) + { + this.modsAddedByAssemblies = modsAddedByAssemblies ?? throw new ArgumentNullException(nameof(modsAddedByAssemblies)); + this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public IEnumerable Run() + { + Stopwatch patchSw = new Stopwatch(); + patchSw.Start(); + + status = "Checking Cache"; + logger.Info(status); + + bool useCache = false; + try + { + useCache = IsCacheUpToDate(); + } + catch (Exception ex) + { + logger.Exception("Exception in IsCacheUpToDate", ex); + } + +#if DEBUG + //useCache = false; +#endif + + IEnumerable databaseConfigs = null; + + if (!useCache) + { + if (!Directory.Exists(logsDirPath)) Directory.CreateDirectory(logsDirPath); + MessageQueue patchLogQueue = new MessageQueue(); + QueueLogRunner logRunner = new QueueLogRunner(patchLogQueue); + ITaskStatus loggingThreadStatus = BackgroundTask.Start(delegate + { + using StreamLogger streamLogger = new StreamLogger(new FileStream(patchLogPath, FileMode.Create)); + streamLogger.Info("Log started at " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")); + logRunner.Run(streamLogger); + streamLogger.Info("Done!"); + }); + IBasicLogger patchLogger = new LogSplitter(logger, new QueueLogger(patchLogQueue)); + + IPatchProgress progress = new PatchProgress(patchLogger); + status = "Pre patch init"; + patchLogger.Info(status); + IEnumerable mods = ModListGenerator.GenerateModList(modsAddedByAssemblies, progress, patchLogger); + + // If we don't use the cache then it is best to clean the PartDatabase.cfg + if (!keepPartDB && File.Exists(partDatabasePath)) + File.Delete(partDatabasePath); + + LoadPhysicsConfig(); + + #region Sorting Patches + + status = "Extracting patches"; + patchLogger.Info(status); + + UrlDir gameData = GameDatabase.Instance.root.children.First(dir => dir.type == UrlDir.DirectoryType.GameData && dir.name == ""); + INeedsChecker needsChecker = new NeedsChecker(mods, gameData, progress, patchLogger); + ITagListParser tagListParser = new TagListParser(progress); + IProtoPatchBuilder protoPatchBuilder = new ProtoPatchBuilder(progress); + IPatchCompiler patchCompiler = new PatchCompiler(); + PatchExtractor extractor = new PatchExtractor(progress, patchLogger, needsChecker, tagListParser, protoPatchBuilder, patchCompiler); + + // Have to convert to an array because we will be removing patches + IEnumerable extractedPatches = + GameDatabase.Instance.root.AllConfigs.Select(urlConfig => extractor.ExtractPatch(urlConfig)).Where(patch => patch != null); + PatchList patchList = new PatchList(mods, extractedPatches, progress); + + #endregion + + #region Applying patches + + status = "Applying patches"; + patchLogger.Info(status); + + IPass currentPass = null; + + progress.OnPassStarted.Add(delegate (IPass pass) + { + currentPass = pass; + StatusUpdate(progress, currentPass.Name); + }); + + System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch(); + stopwatch.Start(); + + progress.OnPatchApplied.Add(delegate + { + long timeRemaining = STATUS_UPDATE_INVERVAL_MS - stopwatch.ElapsedMilliseconds; + if (timeRemaining < 0) + { + StatusUpdate(progress, currentPass.Name); + stopwatch.Reset(); + stopwatch.Start(); + } + }); + + PatchApplier applier = new PatchApplier(progress, patchLogger); + databaseConfigs = applier.ApplyPatches(patchList); + + stopwatch.Stop(); + StatusUpdate(progress); + + patchLogger.Info("Done patching"); + + #endregion Applying patches + + #region Saving Cache + + foreach (KeyValuePair item in progress.Counter.warningFiles) + { + patchLogger.Warning(item.Value + " warning" + (item.Value > 1 ? "s" : "") + " related to GameData/" + item.Key); + } + + if (progress.Counter.errors > 0 || progress.Counter.exceptions > 0) + { + foreach (KeyValuePair item in progress.Counter.errorFiles) + { + errors += item.Value + " error" + (item.Value > 1 ? "s" : "") + " related to GameData/" + item.Key + + "\n"; + } + + patchLogger.Warning("Errors in patch prevents the creation of the cache"); + try + { + if (File.Exists(cachePath)) + File.Delete(cachePath); + if (File.Exists(shaPath)) + File.Delete(shaPath); + } + catch (Exception e) + { + patchLogger.Exception("Exception while deleting stale cache ", e); + } + } + else + { + status = "Saving Cache"; + patchLogger.Info(status); + CreateCache(databaseConfigs, progress.Counter.patchedNodes); + } + + StatusUpdate(progress); + + #endregion Saving Cache + + SaveModdedTechTree(databaseConfigs); + SaveModdedPhysics(databaseConfigs); + + logRunner.RequestStop(); + + while (loggingThreadStatus.IsRunning) + { + System.Threading.Thread.Sleep(100); + } + + if (loggingThreadStatus.IsExitedWithError) + { + logger.Error("The patching thread threw an exception"); + throw loggingThreadStatus.Exception; + } + } + else + { + status = "Loading from Cache"; + logger.Info(status); + databaseConfigs = LoadCache(); + + if (File.Exists(patchLogPath)) + { + logger.Info("Dumping patch log"); + logger.Info("\n#### BEGIN PATCH LOG ####\n\n\n" + File.ReadAllText(patchLogPath) + "\n\n\n#### END PATCH LOG ####"); + } + else + { + logger.Error("Patch log does not exist: " + patchLogPath); + } + } + + if (KSP.Localization.Localizer.Instance != null) + KSP.Localization.Localizer.SwitchToLanguage(KSP.Localization.Localizer.CurrentLanguage); + + logger.Info(status + "\n" + errors); + + patchSw.Stop(); + logger.Info("Ran in " + ((float)patchSw.ElapsedMilliseconds / 1000).ToString("F3") + "s"); + + return databaseConfigs; + } + + private void LoadPhysicsConfig() + { + logger.Info("Loading Physics.cfg"); + UrlDir gameDataDir = GameDatabase.Instance.root.AllDirectories.First(d => d.path.EndsWith("GameData") && d.name == "" && d.url == ""); + // need to use a file with a cfg extension to get the right fileType or you can't AddConfig on it + UrlDir.UrlFile physicsUrlFile = new UrlDir.UrlFile(gameDataDir, new FileInfo(defaultPhysicsPath)); + // Since it loaded the default config badly (sub node only) we clear it first + physicsUrlFile.configs.Clear(); + // And reload it properly + ConfigNode physicsContent = ConfigNode.Load(defaultPhysicsPath); + physicsContent.name = PHYSICS_NODE_NAME; + physicsUrlFile.AddConfig(physicsContent); + gameDataDir.files.Add(physicsUrlFile); + } + + private void SaveModdedPhysics(IEnumerable databaseConfigs) + { + IEnumerable configs = databaseConfigs.Where(config => config.NodeType == PHYSICS_NODE_NAME); + int count = configs.Count(); + + if (count == 0) + { + logger.Info($"No {PHYSICS_NODE_NAME} node found. No custom Physics config will be saved"); + return; + } + + if (count > 1) + { + logger.Info($"{count} {PHYSICS_NODE_NAME} nodes found. A patch may be wrong. Using the first one"); + } + + configs.First().Node.Save(physicsPath); + } + + private bool IsCacheUpToDate() + { + Stopwatch sw = new Stopwatch(); + sw.Start(); + + using System.Security.Cryptography.SHA256 sha = System.Security.Cryptography.SHA256.Create(); + using System.Security.Cryptography.SHA256 filesha = System.Security.Cryptography.SHA256.Create(); + UrlDir.UrlFile[] files = GameDatabase.Instance.root.AllConfigFiles.ToArray(); + + filesSha.Clear(); + + for (int i = 0; i < files.Length; i++) + { + string url = files[i].GetUrlWithExtension(); + // Hash the file path so the checksum change if files are moved + byte[] pathBytes = Encoding.UTF8.GetBytes(url); + sha.TransformBlock(pathBytes, 0, pathBytes.Length, pathBytes, 0); + + // hash the file content + byte[] contentBytes = File.ReadAllBytes(files[i].fullPath); + sha.TransformBlock(contentBytes, 0, contentBytes.Length, contentBytes, 0); + + filesha.ComputeHash(contentBytes); + if (!filesSha.ContainsKey(url)) + { + filesSha.Add(url, BitConverter.ToString(filesha.Hash)); + } + else + { + logger.Warning("Duplicate fileSha key. This should not append. The key is " + url); + } + } + + // Hash the mods dll path so the checksum change if dlls are moved or removed (impact NEEDS) + foreach (AssemblyLoader.LoadedAssembly dll in AssemblyLoader.loadedAssemblies) + { + string path = dll.url + "/" + dll.name; + byte[] pathBytes = Encoding.UTF8.GetBytes(path); + sha.TransformBlock(pathBytes, 0, pathBytes.Length, pathBytes, 0); + } + + foreach (ModListGenerator.ModAddedByAssembly mod in modsAddedByAssemblies) + { + byte[] modBytes = Encoding.UTF8.GetBytes(mod.modName); + sha.TransformBlock(modBytes, 0, modBytes.Length, modBytes, 0); + } + + byte[] godsFinalMessageToHisCreation = Encoding.UTF8.GetBytes("We apologize for the inconvenience."); + sha.TransformFinalBlock(godsFinalMessageToHisCreation, 0, godsFinalMessageToHisCreation.Length); + + configSha = BitConverter.ToString(sha.Hash); + sha.Clear(); + filesha.Clear(); + + sw.Stop(); + + logger.Info("SHA generated in " + ((float)sw.ElapsedMilliseconds / 1000).ToString("F3") + "s"); + logger.Info(" SHA = " + configSha); + + bool useCache = false; + if (File.Exists(shaPath)) + { + ConfigNode shaConfigNode = ConfigNode.Load(shaPath); + if (shaConfigNode != null && shaConfigNode.HasValue("SHA") && shaConfigNode.HasValue("version") && shaConfigNode.HasValue("KSPVersion")) + { + string storedSHA = shaConfigNode.GetValue("SHA"); + string version = shaConfigNode.GetValue("version"); + string kspVersion = shaConfigNode.GetValue("KSPVersion"); + ConfigNode filesShaNode = shaConfigNode.GetNode("FilesSHA"); + useCache = CheckFilesChange(files, filesShaNode); + useCache = useCache && storedSHA.Equals(configSha); + useCache = useCache && version.Equals(Assembly.GetExecutingAssembly().GetName().Version.ToString()); + useCache = useCache && kspVersion.Equals(Versioning.version_major + "." + Versioning.version_minor + "." + Versioning.Revision + "." + Versioning.BuildID); + useCache = useCache && File.Exists(cachePath); + useCache = useCache && File.Exists(physicsPath); + useCache = useCache && File.Exists(techTreePath); + logger.Info("Cache SHA = " + storedSHA); + logger.Info("useCache = " + useCache); + } + } + return useCache; + } + + private bool CheckFilesChange(UrlDir.UrlFile[] files, ConfigNode shaConfigNode) + { + bool noChange = true; + StringBuilder changes = new StringBuilder(); + + changes.Append("Changes :\n"); + + for (int i = 0; i < files.Length; i++) + { + string url = files[i].GetUrlWithExtension(); + ConfigNode fileNode = GetFileNode(shaConfigNode, url); + string fileSha = fileNode?.GetValue("SHA"); + + if (fileNode == null) + continue; + + if (fileSha == null || filesSha[url] != fileSha) + { + changes.Append("Changed : " + fileNode.GetValue("filename") + ".cfg\n"); + noChange = false; + } + } + for (int i = 0; i < files.Length; i++) + { + string url = files[i].GetUrlWithExtension(); + ConfigNode fileNode = GetFileNode(shaConfigNode, url); + + if (fileNode == null) + { + changes.Append("Added : " + url + "\n"); + noChange = false; + } + shaConfigNode.RemoveNode(fileNode); + } + foreach (ConfigNode fileNode in shaConfigNode.GetNodes()) + { + changes.Append("Deleted : " + fileNode.GetValue("filename") + "\n"); + noChange = false; + } + if (!noChange) + logger.Info(changes.ToString()); + return noChange; + } + + private ConfigNode GetFileNode(ConfigNode shaConfigNode, string filename) + { + for (int i = 0; i < shaConfigNode.nodes.Count; i++) + { + ConfigNode file = shaConfigNode.nodes[i]; + if (file.name == "FILE" && file.GetValue("filename") == filename) + return file; + } + return null; + } + + + private void CreateCache(IEnumerable databaseConfigs, int patchedNodeCount) + { + ConfigNode shaConfigNode = new ConfigNode(); + shaConfigNode.AddValue("SHA", configSha); + shaConfigNode.AddValue("version", Assembly.GetExecutingAssembly().GetName().Version.ToString()); + shaConfigNode.AddValue("KSPVersion", Versioning.version_major + "." + Versioning.version_minor + "." + Versioning.Revision + "." + Versioning.BuildID); + ConfigNode filesSHANode = shaConfigNode.AddNode("FilesSHA"); + + ConfigNode cache = new ConfigNode(); + + cache.AddValue("patchedNodeCount", patchedNodeCount.ToString()); + + foreach (IProtoUrlConfig urlConfig in databaseConfigs) + { + ConfigNode node = cache.AddNode("UrlConfig"); + node.AddValue("parentUrl", urlConfig.UrlFile.GetUrlWithExtension()); + + ConfigNode urlNode = urlConfig.Node.DeepCopy(); + urlNode.EscapeValuesRecursive(); + + node.AddNode(urlNode); + } + + foreach (var file in GameDatabase.Instance.root.AllConfigFiles) + { + string url = file.GetUrlWithExtension(); + // "/Physics" is the node we created manually to loads the PHYSIC config + if (file.url != "/Physics" && filesSha.ContainsKey(url)) + { + ConfigNode shaNode = filesSHANode.AddNode("FILE"); + shaNode.AddValue("filename", url); + shaNode.AddValue("SHA", filesSha[url]); + filesSha.Remove(url); + } + } + + logger.Info("Saving cache"); + + try + { + shaConfigNode.Save(shaPath); + } + catch (Exception e) + { + logger.Exception("Exception while saving the sha", e); + } + try + { + cache.Save(cachePath); + return; + } + catch (NullReferenceException e) + { + logger.Exception("NullReferenceException while saving the cache", e); + } + catch (Exception e) + { + logger.Exception("Exception while saving the cache", e); + } + + try + { + logger.Error("An error occured while creating the cache. Deleting the cache files to avoid keeping a bad cache"); + if (File.Exists(cachePath)) + File.Delete(cachePath); + if (File.Exists(shaPath)) + File.Delete(shaPath); + } + catch (Exception e) + { + logger.Exception("Exception while deleting the cache", e); + } + } + + private void SaveModdedTechTree(IEnumerable databaseConfigs) + { + IEnumerable configs = databaseConfigs.Where(config => config.NodeType == TECH_TREE_NODE_NAME); + int count = configs.Count(); + + if (count == 0) + { + logger.Info($"No {TECH_TREE_NODE_NAME} node found. No custom {TECH_TREE_NODE_NAME} will be saved"); + return; + } + + if (count > 1) + { + logger.Info($"{count} {TECH_TREE_NODE_NAME} nodes found. A patch may be wrong. Using the first one"); + } + + ConfigNode techNode = new ConfigNode(TECH_TREE_NODE_NAME); + techNode.AddNode(configs.First().Node); + techNode.Save(techTreePath); + } + + private IEnumerable LoadCache() + { + ConfigNode cache = ConfigNode.Load(cachePath); + + if (cache.HasValue("patchedNodeCount") && int.TryParse(cache.GetValue("patchedNodeCount"), out int patchedNodeCount)) + status = "ModuleManager: " + patchedNodeCount + " patch" + (patchedNodeCount != 1 ? "es" : "") + " loaded from cache"; + + // Create the fake file where we load the physic config cache + UrlDir gameDataDir = GameDatabase.Instance.root.AllDirectories.First(d => d.path.EndsWith("GameData") && d.name == "" && d.url == ""); + // need to use a file with a cfg extension to get the right fileType or you can't AddConfig on it + UrlDir.UrlFile physicsUrlFile = new UrlDir.UrlFile(gameDataDir, new FileInfo(defaultPhysicsPath)); + gameDataDir.files.Add(physicsUrlFile); + + List databaseConfigs = new List(cache.nodes.Count); + + foreach (ConfigNode node in cache.nodes) + { + string parentUrl = node.GetValue("parentUrl"); + + UrlDir.UrlFile parent = gameDataDir.Find(parentUrl); + if (parent != null) + { + node.nodes[0].UnescapeValuesRecursive(); + databaseConfigs.Add(new ProtoUrlConfig(parent, node.nodes[0])); + } + else + { + logger.Warning("Parent null for " + parentUrl); + } + } + logger.Info("Cache Loaded"); + + return databaseConfigs; + } + + private void StatusUpdate(IPatchProgress progress, string activity = null) + { + status = "ModuleManager: " + progress.Counter.patchedNodes + " patch" + (progress.Counter.patchedNodes != 1 ? "es" : "") + " applied"; + if (progress.ProgressFraction < 1f - float.Epsilon) + status += " (" + progress.ProgressFraction.ToString("P0") + ")"; + + if (activity != null) + status += "\n" + activity; + + if (progress.Counter.warnings > 0) + status += ", found " + progress.Counter.warnings + " warning" + (progress.Counter.warnings != 1 ? "s" : "") + ""; + + if (progress.Counter.errors > 0) + status += ", found " + progress.Counter.errors + " error" + (progress.Counter.errors != 1 ? "s" : "") + ""; + + if (progress.Counter.exceptions > 0) + status += ", encountered " + progress.Counter.exceptions + " exception" + (progress.Counter.exceptions != 1 ? "s" : "") + ""; + } + + #region Applying Patches + + // Name is group 1, index is group 2, vector related filed is group 3, vector separator is group 4, operator is group 5 + private static readonly Regex parseValue = new Regex(@"([\w\&\-\.\?\*\#+/^!\(\) ]+(?:,[^*\d][\w\&\-\.\?\*\(\) ]*)*)(?:,(-?[0-9\*]+))?(?:\[((?:[0-9\*]+)+)(?:,(.))?\])?"); + + // ModifyNode applies the ConfigNode mod as a 'patch' to ConfigNode original, then returns the patched ConfigNode. + // it uses FindConfigNodeIn(src, nodeType, nodeName, nodeTag) to recurse. + public static ConfigNode ModifyNode(NodeStack original, ConfigNode mod, PatchContext context) + { + ConfigNode newNode = original.value.DeepCopy(); + NodeStack nodeStack = original.ReplaceValue(newNode); + + #region Values + + #if LOGSPAM + string vals = "[ModuleManager] modding values"; + #endif + foreach (ConfigNode.Value modVal in mod.values) + { + #if LOGSPAM + vals += "\n " + modVal.name + "= " + modVal.value; + #endif + + Command cmd = CommandParser.Parse(modVal.name, out string valName); + + Operator op; + if (valName.Length > 2 && valName[valName.Length - 2] == ',') + op = Operator.Assign; + else + op = OperatorParser.Parse(valName, out valName); + + if (cmd == Command.Special) + { + ConfigNode.Value val = RecurseVariableSearch(valName, nodeStack.Push(mod), context); + + if (val == null) + { + context.progress.Error(context.patchUrl, "Error - Cannot find value assigning command: " + valName); + continue; + } + + if (op != Operator.Assign) + { + if (double.TryParse(modVal.value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double s) + && double.TryParse(val.value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double os)) + { + switch (op) + { + case Operator.Multiply: + val.value = (os * s).ToString(CultureInfo.InvariantCulture); + break; + + case Operator.Divide: + val.value = (os / s).ToString(CultureInfo.InvariantCulture); + break; + + case Operator.Add: + val.value = (os + s).ToString(CultureInfo.InvariantCulture); + break; + + case Operator.Subtract: + val.value = (os - s).ToString(CultureInfo.InvariantCulture); + break; + + case Operator.Exponentiate: + val.value = Math.Pow(os, s).ToString(CultureInfo.InvariantCulture); + break; + } + } + } + else + { + val.value = modVal.value; + } + continue; + } + + Match match = parseValue.Match(valName); + if (!match.Success) + { + context.progress.Error(context.patchUrl, "Error - Cannot parse value modifying command: " + valName); + continue; + } + + // Get the bits and pieces from the regexp + valName = match.Groups[1].Value; + + // Get a position for editing a vector + int position = 0; + bool isPosStar = false; + if (match.Groups[3].Success) + { + if (match.Groups[3].Value == "*") + isPosStar = true; + else if (!int.TryParse(match.Groups[3].Value, out position)) + { + context.progress.Error(context.patchUrl, "Error - Unable to parse number as number. Very odd."); + continue; + } + } + char seperator = ','; + if (match.Groups[4].Success) + { + seperator = match.Groups[4].Value[0]; + } + + // In this case insert the value at position index (with the same node names) + int index = 0; + bool isStar = false; + if (match.Groups[2].Success) + { + if (match.Groups[2].Value == "*") + isStar = true; + // can have "node,n *" (for *= ect) + else if (!int.TryParse(match.Groups[2].Value, out index)) + { + context.progress.Error(context.patchUrl, "Error - Unable to parse number as number. Very odd."); + continue; + } + } + + int valCount = 0; + for (int i=0; i " + value; + #endif + + if (cmd != Command.Copy) + origVal.value = value; + else + newNode.AddValueSafe(valName, value); + } + } + else + { + context.progress.Error(context.patchUrl, "Error - Cannot parse variable search when editing key " + valName + " = " + modVal.value); + } + + if (isStar) index++; + else break; + } + break; + + case Command.Delete: + if (match.Groups[5].Success) + { + context.progress.Error(context.patchUrl, "Error - Cannot use operators with delete (- or !) value: " + mod.name); + } + else if (match.Groups[2].Success) + { + while (index < valCount) + { + // If there is an index, use it. + ConfigNode.Value v = FindValueIn(newNode, valName, index); + if (v != null) + newNode.values.Remove(v); + if (isStar) index++; + else break; + } + } + else if (valName.Contains('*') || valName.Contains('?')) + { + // Delete all matching wildcard + ConfigNode.Value last = null; + while (true) + { + ConfigNode.Value v = FindValueIn(newNode, valName, index++); + if (v == last) + break; + last = v; + newNode.values.Remove(v); + } + } + else + { + // Default is to delete ALL values that match. (backwards compatibility) + newNode.RemoveValues(valName); + } + break; + + case Command.Rename: + if (nodeStack.IsRoot) + { + context.progress.Error(context.patchUrl, "Error - Renaming nodes does not work on top nodes"); + break; + } + newNode.name = modVal.value; + break; + + case Command.Create: + if (match.Groups[2].Success || match.Groups[5].Success || valName.Contains('*') + || valName.Contains('?')) + { + if (match.Groups[2].Success) + context.progress.Error(context.patchUrl, "Error - Cannot use index with create (&) value: " + mod.name); + if (match.Groups[5].Success) + context.progress.Error(context.patchUrl, "Error - Cannot use operators with create (&) value: " + mod.name); + if (valName.Contains('*') || valName.Contains('?')) + context.progress.Error(context.patchUrl, "Error - Cannot use wildcards (* or ?) with create (&) value: " + mod.name); + } + else + { + varValue = ProcessVariableSearch(modVal.value, nodeStack, context); + if (varValue != null) + { + if (!newNode.HasValue(valName)) + newNode.AddValueSafe(valName, varValue); + } + else + { + context.progress.Error(context.patchUrl, "Error - Cannot parse variable search when replacing (&) key " + valName + " = " + + modVal.value); + } + } + break; + } + } + #if LOGSPAM + log(vals); + #endif + + #endregion Values + + #region Nodes + + foreach (ConfigNode subMod in mod.nodes) + { + subMod.name = subMod.name.RemoveWS(); + + if (!subMod.name.IsBracketBalanced()) + { + context.progress.Error(context.patchUrl, + "Error - Skipping a patch subnode with unbalanced square brackets or a space (replace them with a '?') in " + + mod.name + " : \n" + subMod.name + "\n"); + continue; + } + + string subName = subMod.name; + Command command = CommandParser.Parse(subName, out string tmp); + + if (command == Command.Insert) + { + ConfigNode newSubMod = new ConfigNode(subMod.name); + newSubMod = ModifyNode(nodeStack.Push(newSubMod), subMod, context); + subName = newSubMod.name; + if (subName.Contains(",") && int.TryParse(subName.Split(',')[1], out int index)) + { + // In this case insert the node at position index (with the same node names) + newSubMod.name = subName.Split(',')[0]; + InsertNode(newNode, newSubMod, index); + } + else + { + newNode.AddNode(newSubMod); + } + } + else if (command == Command.Paste) + { + //int start = subName.IndexOf('['); + //int end = subName.LastIndexOf(']'); + //if (start == -1 || end == -1 || end - start < 1) + //{ + // log("Pasting a node require a [path] to the node to paste" + mod.name + " : \n" + subMod.name + "\n"); + // errorCount++; + // continue; + //} + + //string newName = subName.Substring(0, start); + //string path = subName.Substring(start + 1, end - start - 1); + + ConfigNode toPaste = RecurseNodeSearch(subName.Substring(1), nodeStack, context); + + if (toPaste == null) + { + context.progress.Error(context.patchUrl, "Error - Can not find the node to paste in " + mod.name + " : " + subMod.name + "\n"); + continue; + } + + ConfigNode newSubMod = new ConfigNode(toPaste.name); + newSubMod = ModifyNode(nodeStack.Push(newSubMod), toPaste, context); + if (subName.LastIndexOf(',') > 0 && int.TryParse(subName.Substring(subName.LastIndexOf(',') + 1), out int index)) + { + // In this case insert the node at position index + InsertNode(newNode, newSubMod, index); + } + else + newNode.AddNode(newSubMod); + } + else + { + string constraints = ""; + string tag = ""; + string nodeType, nodeName; + int index = 0; + #if LOGSPAM + string msg = ""; + #endif + List subNodes = new List(); + + // three ways to specify: + // NODE,n will match the nth node (NODE is the same as NODE,0) + // NODE,* will match ALL nodes + // NODE:HAS[condition] will match ALL nodes with condition + if (subName.Contains(":HAS[", out int hasStart)) + { + constraints = subName.Substring(hasStart + 5, subName.LastIndexOf(']') - hasStart - 5); + subName = subName.Substring(0, hasStart); + } + + if (subName.Contains(",")) + { + tag = subName.Split(',')[1]; + subName = subName.Split(',')[0]; + int.TryParse(tag, out index); + } + + if (subName.Contains("[")) + { + // format @NODETYPE[Name] {...} + // or @NODETYPE[Name, index] {...} + nodeType = subName.Substring(1).Split('[')[0]; + nodeName = subName.Split('[')[1].Replace("]", ""); + } + else + { + // format @NODETYPE {...} or ! instead of @ + nodeType = subName.Substring(1); + nodeName = null; + } + + if (tag == "*" || constraints.Length > 0) + { + // get ALL nodes + if (command != Command.Replace) + { + ConfigNode n, last = null; + while (true) + { + n = FindConfigNodeIn(newNode, nodeType, nodeName, index++); + if (n == last || n == null) + break; + if (CheckConstraints(n, constraints)) + subNodes.Add(n); + last = n; + } + } +#if LOGSPAM + else + msg += " cannot wildcard a % node: " + subMod.name + "\n"; +#endif + } + else + { + // just get one node + ConfigNode n = FindConfigNodeIn(newNode, nodeType, nodeName, index); + if (n != null) + subNodes.Add(n); + } + + if (command == Command.Replace) + { + // if the original exists modify it + if (subNodes.Count > 0) + { + #if LOGSPAM + msg += " Applying subnode " + subMod.name + "\n"; + #endif + ConfigNode newSubNode = ModifyNode(nodeStack.Push(subNodes[0]), subMod, context); + subNodes[0].ShallowCopyFrom(newSubNode); + subNodes[0].name = newSubNode.name; + } + else + { + // if not add the mod node without the % in its name + #if LOGSPAM + msg += " Adding subnode " + subMod.name + "\n"; + #endif + + ConfigNode copy = new ConfigNode(nodeType); + + if (nodeName != null) + copy.AddValueSafe("name", nodeName); + + ConfigNode newSubNode = ModifyNode(nodeStack.Push(copy), subMod, context); + newNode.nodes.Add(newSubNode); + } + } + else if (command == Command.Create) + { + if (subNodes.Count == 0) + { + #if LOGSPAM + msg += " Adding subnode " + subMod.name + "\n"; + #endif + + ConfigNode copy = new ConfigNode(nodeType); + + if (nodeName != null) + copy.AddValueSafe("name", nodeName); + + ConfigNode newSubNode = ModifyNode(nodeStack.Push(copy), subMod, context); + newNode.nodes.Add(newSubNode); + } + } + else + { + // find each original subnode to modify, modify it and add the modified. + #if LOGSPAM + if (subNodes.Count == 0) // no nodes to modify! + msg += " Could not find node(s) to modify: " + subMod.name + "\n"; + #endif + + foreach (ConfigNode subNode in subNodes) + { + #if LOGSPAM + msg += " Applying subnode " + subMod.name + "\n"; + #endif + ConfigNode newSubNode; + switch (command) + { + case Command.Edit: + + // Edit in place + newSubNode = ModifyNode(nodeStack.Push(subNode), subMod, context); + subNode.ShallowCopyFrom(newSubNode); + subNode.name = newSubNode.name; + break; + + case Command.Delete: + + // Delete the node + newNode.nodes.Remove(subNode); + break; + + case Command.Copy: + + // Copy the node + newSubNode = ModifyNode(nodeStack.Push(subNode), subMod, context); + newNode.nodes.Add(newSubNode); + break; + } + } + } + #if LOGSPAM + print(msg); + #endif + } + } + + #endregion Nodes + + return newNode; + } + + + // Search for a ConfigNode by a path alike string + private static ConfigNode RecurseNodeSearch(string path, NodeStack nodeStack, PatchContext context) + { + //log("Path : \"" + path + "\""); + + if (path[0] == '/') + { + return RecurseNodeSearch(path.Substring(1), nodeStack.Root, context); + } + + int nextSep = path.IndexOf('/'); + + bool root = (path[0] == '@'); + int shift = root ? 1 : 0; + string subName = (nextSep != -1) ? path.Substring(shift, nextSep - shift) : path.Substring(shift); + string nodeType, nodeName; + string constraint = ""; + + int index = 0; + if (subName.Contains(":HAS[", out int hasStart)) + { + constraint = subName.Substring(hasStart + 5, subName.LastIndexOf(']') - hasStart - 5); + subName = subName.Substring(0, hasStart); + } + else if (subName.Contains(",")) + { + string tag = subName.Split(',')[1]; + subName = subName.Split(',')[0]; + int.TryParse(tag, out index); + } + + if (subName.Contains("[")) + { + // NODETYPE[Name] + nodeType = subName.Split('[')[0]; + nodeName = subName.Split('[')[1].Replace("]", ""); + } + else + { + // NODETYPE + nodeType = subName; + nodeName = null; + } + + // ../XXXXX + if (path.StartsWith("../")) + { + if (nodeStack.IsRoot) + return null; + + return RecurseNodeSearch(path.Substring(3), nodeStack.Pop(), context); + } + + //log("nextSep : \"" + nextSep + " \" root : \"" + root + " \" nodeType : \"" + nodeType + "\" nodeName : \"" + nodeName + "\""); + + // @XXXXX + if (root) + { + bool foundNodeType = false; + foreach (IProtoUrlConfig urlConfig in context.databaseConfigs) + { + ConfigNode node = urlConfig.Node; + + if (node.name != nodeType) continue; + + foundNodeType = true; + + if (nodeName == null || (node.GetValue("name") is string testNodeName && WildcardMatch(testNodeName, nodeName))) + { + nodeStack = new NodeStack(node); + break; + } + } + + if (!foundNodeType) context.logger.Warning("Can't find nodeType:" + nodeType); + if (nodeStack == null) return null; + } + else + { + if (constraint.Length > 0) + { + // get the first one matching + ConfigNode last = null; + while (true) + { + ConfigNode n = FindConfigNodeIn(nodeStack.value, nodeType, nodeName, index++); + if (n == last || n == null) + { + nodeStack = null; + break; + } + if (CheckConstraints(n, constraint)) + { + nodeStack = nodeStack.Push(n); + break; + } + last = n; + } + } + else + { + // just get one node + nodeStack = nodeStack.Push(FindConfigNodeIn(nodeStack.value, nodeType, nodeName, index)); + } + } + + // XXXXXX/ + if (nextSep > 0 && nodeStack != null) + { + path = path.Substring(nextSep + 1); + //log("NewPath : \"" + path + "\""); + return RecurseNodeSearch(path, nodeStack, context); + } + + return nodeStack.value; + } + + // KeyName is group 1, index is group 2, value index is group 3, value separator is group 4 + private static readonly Regex parseVarKey = new Regex(@"([\w\&\-\.]+)(?:,((?:[0-9]+)+))?(?:\[((?:[0-9]+)+)(?:,(.))?\])?"); + + // Search for a value by a path alike string + private static ConfigNode.Value RecurseVariableSearch(string path, NodeStack nodeStack, PatchContext context) + { + //log("path:" + path); + if (path[0] == '/') + return RecurseVariableSearch(path.Substring(1), nodeStack.Root, context); + int nextSep = path.IndexOf('/'); + + // make sure we don't stop on a ",/" which would be a value separator + // it's a hack that should be replaced with a proper regex for the whole node search + while (nextSep > 0 && path[nextSep - 1] == ',') + nextSep = path.IndexOf('/', nextSep + 1); + + if (path[0] == '@') + { + if (nextSep < 2) + return null; + + string subName = path.Substring(1, nextSep - 1); + string nodeType, nodeName; + + if (subName.Contains("[")) + { + // @NODETYPE[Name]/ + nodeType = subName.Split('[')[0]; + nodeName = subName.Split('[')[1].Replace("]", ""); + } + else + { + // @NODETYPE/ + nodeType = subName; + nodeName = null; + } + + bool foundNodeType = false; + foreach (IProtoUrlConfig urlConfig in context.databaseConfigs) + { + ConfigNode node = urlConfig.Node; + + if (node.name != nodeType) continue; + + foundNodeType = true; + + if (nodeName == null || (node.GetValue("name") is string testNodeName && WildcardMatch(testNodeName, nodeName))) + { + return RecurseVariableSearch(path.Substring(nextSep + 1), new NodeStack(node), context); + } + } + + if (!foundNodeType) context.logger.Warning("Can't find nodeType:" + nodeType); + + return null; + } + if (path.StartsWith("../")) + { + if (nodeStack.IsRoot) + return null; + + return RecurseVariableSearch(path.Substring(3), nodeStack.Pop(), context); + } + + // Node search + if (nextSep > 0 && path[nextSep - 1] != ',') + { + // Big case of code duplication here ... + // TODO : replace with a regex + + string subName = path.Substring(0, nextSep); + string constraint = ""; + string nodeType, nodeName; + int index = 0; + if (subName.Contains(":HAS[", out int hasStart)) + { + constraint = subName.Substring(hasStart + 5, subName.LastIndexOf(']') - hasStart - 5); + subName = subName.Substring(0, hasStart); + } + else if (subName.Contains(',')) + { + string tag = subName.Split(',')[1]; + subName = subName.Split(',')[0]; + int.TryParse(tag, out index); + } + + if (subName.Contains("[")) + { + // format NODETYPE[Name] {...} + // or NODETYPE[Name, index] {...} + nodeType = subName.Split('[')[0]; + nodeName = subName.Split('[')[1].Replace("]", ""); + } + else + { + // format NODETYPE {...} + nodeType = subName; + nodeName = null; + } + + if (constraint.Length > 0) + { + // get the first one matching + ConfigNode last = null; + while (true) + { + ConfigNode n = FindConfigNodeIn(nodeStack.value, nodeType, nodeName, index++); + if (n == last || n == null) + break; + if (CheckConstraints(n, constraint)) + return RecurseVariableSearch(path.Substring(nextSep + 1), nodeStack.Push(n), context); + last = n; + } + return null; + } + else + { + // just get one node + ConfigNode n = FindConfigNodeIn(nodeStack.value, nodeType, nodeName, index); + if (n != null) + return RecurseVariableSearch(path.Substring(nextSep + 1), nodeStack.Push(n), context); + return null; + } + } + + // Value search + + Match match = parseVarKey.Match(path); + if (!match.Success) + { + context.logger.Warning("Cannot parse variable search command: " + path); + return null; + } + + string valName = match.Groups[1].Value; + + int idx = 0; + if (match.Groups[2].Success) + int.TryParse(match.Groups[2].Value, out idx); + + ConfigNode.Value cVal = FindValueIn(nodeStack.value, valName, idx); + if (cVal == null) + { + context.logger.Warning("Cannot find key " + valName + " in " + nodeStack.value.name); + return null; + } + + if (match.Groups[3].Success) + { + ConfigNode.Value newVal = new ConfigNode.Value(cVal.name, cVal.value); + int.TryParse(match.Groups[3].Value, out int splitIdx); + + char sep = ','; + if (match.Groups[4].Success) + sep = match.Groups[4].Value[0]; + string[] split = newVal.value.Split(sep); + if (splitIdx < split.Length) + newVal.value = split[splitIdx]; + else + newVal.value = ""; + return newVal; + } + return cVal; + } + + private static string ProcessVariableSearch(string value, NodeStack nodeStack, PatchContext context) + { + // value = #xxxx$yyyyy$zzzzz$aaaa$bbbb + // There is 2 or more '$' + if (value.Length > 0 && value[0] == '#' && value.IndexOf('$') != -1 && value.IndexOf('$') != value.LastIndexOf('$')) + { + //log("variable search input : =\"" + value + "\""); + string[] split = value.Split('$'); + + if (split.Length % 2 != 1) + return null; + + StringBuilder builder = new StringBuilder(); + builder.Append(split[0].Substring(1)); + + for (int i = 1; i < split.Length - 1; i += 2) + { + ConfigNode.Value result = RecurseVariableSearch(split[i], nodeStack, context); + if (result == null || result.value == null) + return null; + builder.Append(result.value); + builder.Append(split[i + 1]); + } + value = builder.ToString(); + //log("variable search output : =\"" + value + "\""); + } + return value; + } + + private static string FindAndReplaceValue( + ConfigNode mod, + ref string valName, + string value, + ConfigNode newNode, + Operator op, + int index, + out ConfigNode.Value origVal, + PatchContext context, + bool hasPosIndex = false, + int posIndex = 0, + bool hasPosStar = false, + char seperator = ',') + { + origVal = FindValueIn(newNode, valName, index); + if (origVal == null) + return null; + string oValue = origVal.value; + + string[] strArray = new string[] { oValue }; + if (hasPosIndex) + { + strArray = oValue.Split(new char[] { seperator }, StringSplitOptions.RemoveEmptyEntries); + if (posIndex >= strArray.Length) + { + context.progress.Error(context.patchUrl, "Invalid Vector Index!"); + return null; + } + } + string backupValue = value; + while (posIndex < strArray.Length) + { + value = backupValue; + oValue = strArray[posIndex]; + if (op != Operator.Assign) + { + if (op == Operator.RegexReplace) + { + try + { + string[] split = value.Split(value[0]); + + Regex replace = regexCache.Fetch(split[1], delegate + { + return new Regex(split[1]); + }); + + value = replace.Replace(oValue, split[2]); + } + catch (Exception ex) + { + context.progress.Exception(context.patchUrl, "Error - Failed to do a regexp replacement: " + mod.name + " : original value=\"" + oValue + + "\" regexp=\"" + value + + "\" \nNote - to use regexp, the first char is used to subdivide the string (much like sed)", ex); + return null; + } + } + else if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double s) + && double.TryParse(oValue, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double os)) + { + switch (op) + { + case Operator.Multiply: + value = (os * s).ToString(CultureInfo.InvariantCulture); + break; + + case Operator.Divide: + value = (os / s).ToString(CultureInfo.InvariantCulture); + break; + + case Operator.Add: + value = (os + s).ToString(CultureInfo.InvariantCulture); + break; + + case Operator.Subtract: + value = (os - s).ToString(CultureInfo.InvariantCulture); + break; + + case Operator.Exponentiate: + value = Math.Pow(os, s).ToString(CultureInfo.InvariantCulture); + break; + } + } + else + { + context.progress.Error(context.patchUrl, "Error - Failed to do a maths replacement: " + mod.name + " : original value=\"" + oValue + + "\" operator=" + op + " mod value=\"" + value + "\""); + return null; + } + } + strArray[posIndex] = value; + if (hasPosStar) posIndex++; + else break; + } + value = String.Join(new string(seperator, 1), strArray); + return value; + } + + #endregion Applying Patches + + #region Condition checking + + // Split condiction while not getting lost in embeded brackets + public static List SplitConstraints(string condition) + { + condition = condition.RemoveWS() + ","; + List conditions = new List(); + int start = 0; + int level = 0; + for (int end = 0; end < condition.Length; end++) + { + if ((condition[end] == ',' || condition[end] == '&') && level == 0) + { + conditions.Add(condition.Substring(start, end - start)); + start = end + 1; + } + else if (condition[end] == '[') + level++; + else if (condition[end] == ']') + level--; + } + return conditions; + } + + static readonly char[] contraintSeparators = { '[', ']' }; + + public static bool CheckConstraints(ConfigNode node, string constraints) + { + constraints = constraints.RemoveWS(); + + if (constraints.Length == 0) + return true; + + List constraintList = SplitConstraints(constraints); + + if (constraintList.Count == 1) + { + constraints = constraintList[0]; + + string remainingConstraints = ""; + if (constraints.Contains(":HAS[", out int hasStart)) + { + hasStart += 5; + remainingConstraints = constraints.Substring(hasStart, constraintList[0].LastIndexOf(']') - hasStart); + constraints = constraints.Substring(0, hasStart - 5); + } + + string[] splits = constraints.Split(contraintSeparators, 3); + string type = splits[0].Substring(1); + string name = splits.Length > 1 ? splits[1] : null; + + switch (constraints[0]) + { + case '@': + case '!': + + // @MODULE[ModuleAlternator] or !MODULE[ModuleAlternator] + bool not = (constraints[0] == '!'); + + bool any = false; + int index = 0; + ConfigNode last = null; + while (true) + { + ConfigNode subNode = FindConfigNodeIn(node, type, name, index++); + if (subNode == last || subNode == null) + break; + any = any || CheckConstraints(subNode, remainingConstraints); + last = subNode; + } + if (last != null) + { + //print("CheckConstraints: " + constraints + " " + (not ^ any)); + return not ^ any; + } + //print("CheckConstraints: " + constraints + " " + (not ^ false)); + return not ^ false; + + case '#': + + // #module[Winglet] + if (node.HasValue(type) && WildcardMatchValues(node, type, name)) + { + bool ret2 = CheckConstraints(node, remainingConstraints); + //print("CheckConstraints: " + constraints + " " + ret2); + return ret2; + } + //print("CheckConstraints: " + constraints + " false"); + return false; + + case '~': + + // ~breakingForce[] breakingForce is not present + // or: ~breakingForce[100] will be true if it's present but not 100, too. + if (name == "" && node.HasValue(type)) + { + //print("CheckConstraints: " + constraints + " false"); + return false; + } + if (name != "" && WildcardMatchValues(node, type, name)) + { + //print("CheckConstraints: " + constraints + " false"); + return false; + } + bool ret = CheckConstraints(node, remainingConstraints); + //print("CheckConstraints: " + constraints + " " + ret); + return ret; + + default: + //print("CheckConstraints: " + constraints + " false"); + return false; + } + } + + bool ret3 = true; + foreach (string constraint in constraintList) + { + ret3 = ret3 && CheckConstraints(node, constraint); + } + //print("CheckConstraints: " + constraints + " " + ret3); + return ret3; + } + + public static bool WildcardMatchValues(ConfigNode node, string type, string value) + { + double val = 0; + bool compare = value != null && value.Length > 1 && (value[0] == '<' || value[0] == '>'); + compare = compare && double.TryParse(value.Substring(1), NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out val); + + string[] values = node.GetValues(type); + for (int i = 0; i < values.Length; i++) + { + if (!compare && WildcardMatch(values[i], value)) + return true; + + if (compare && double.TryParse(values[i], NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double val2) + && ((value[0] == '<' && val2 < val) || (value[0] == '>' && val2 > val))) + { + return true; + } + } + return false; + } + + public static bool WildcardMatch(string s, string wildcard) + { + if (wildcard == null) + return true; + string pattern = "^" + Regex.Escape(wildcard).Replace(@"\*", ".*").Replace(@"\?", ".") + "$"; + + Regex regex = regexCache.Fetch(pattern, delegate + { + return new Regex(pattern); + }); + return regex.IsMatch(s); + } + + #endregion Condition checking + + #region Config Node Utilities + + private static void InsertNode(ConfigNode newNode, ConfigNode subMod, int index) + { + string modName = subMod.name; + + ConfigNode[] oldValues = newNode.GetNodes(modName); + if (index < oldValues.Length) + { + newNode.RemoveNodes(modName); + int i = 0; + for (; i < index; ++i) + newNode.AddNode(oldValues[i]); + newNode.AddNode(subMod); + for (; i < oldValues.Length; ++i) + newNode.AddNode(oldValues[i]); + } + else + newNode.AddNode(subMod); + } + + private static void InsertValue(ConfigNode newNode, int index, string name, string value) + { + string[] oldValues = newNode.GetValues(name); + if (index < oldValues.Length) + { + newNode.RemoveValues(name); + int i = 0; + for (; i < index; ++i) + newNode.AddValueSafe(name, oldValues[i]); + newNode.AddValueSafe(name, value); + for (; i < oldValues.Length; ++i) + newNode.AddValueSafe(name, oldValues[i]); + return; + } + newNode.AddValueSafe(name, value); + } + + //FindConfigNodeIn finds and returns a ConfigNode in src of type nodeType. + //If nodeName is not null, it will only find a node of type nodeType with the value name=nodeName. + //If nodeTag is not null, it will only find a node of type nodeType with the value name=nodeName and tag=nodeTag. + public static ConfigNode FindConfigNodeIn( + ConfigNode src, + string nodeType, + string nodeName = null, + int index = 0) + { + List nodes = new List(); + int c = src.nodes.Count; + for(int i = 0; i < c; ++i) + { + if (WildcardMatch(src.nodes[i].name, nodeType)) + nodes.Add(src.nodes[i]); + } + int nodeCount = nodes.Count; + if (nodeCount == 0) + return null; + if (nodeName == null) + { + if (index >= 0) + return nodes[Math.Min(index, nodeCount - 1)]; + return nodes[Math.Max(0, nodeCount + index)]; + } + ConfigNode last = null; + if (index >= 0) + { + for (int i = 0; i < nodeCount; ++i) + { + if (nodes[i].HasValue("name") && WildcardMatch(nodes[i].GetValue("name"), nodeName)) + { + last = nodes[i]; + if (--index < 0) + return last; + } + } + return last; + } + for (int i = nodeCount - 1; i >= 0; --i) + { + if (nodes[i].HasValue("name") && WildcardMatch(nodes[i].GetValue("name"), nodeName)) + { + last = nodes[i]; + if (++index >= 0) + return last; + } + } + return last; + } + + private static ConfigNode.Value FindValueIn(ConfigNode newNode, string valName, int index) + { + ConfigNode.Value v = null; + for (int i = 0; i < newNode.values.Count; ++i) + { + if (WildcardMatch(newNode.values[i].name, valName)) + { + v = newNode.values[i]; + if (--index < 0) + return v; + } + } + return v; + } + + #endregion Config Node Utilities + } +} diff --git a/ModuleManager/MMPatchRunner.cs b/ModuleManager/MMPatchRunner.cs new file mode 100644 index 00000000..6c3d63a0 --- /dev/null +++ b/ModuleManager/MMPatchRunner.cs @@ -0,0 +1,98 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using ModuleManager.Collections; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.Threading; + +using static ModuleManager.FilePathRepository; + +namespace ModuleManager +{ + public class MMPatchRunner + { + private readonly IBasicLogger kspLogger; + + public string Status { get; private set; } = ""; + public string Errors { get; private set; } = ""; + + public MMPatchRunner(IBasicLogger kspLogger) + { + this.kspLogger = kspLogger ?? throw new ArgumentNullException(nameof(kspLogger)); + } + + public IEnumerator Run() + { + PostPatchLoader.Instance.databaseConfigs = null; + + if (!Directory.Exists(logsDirPath)) Directory.CreateDirectory(logsDirPath); + + kspLogger.Info("Patching started on a new thread, all output will be directed to " + logPath); + + MessageQueue mmLogQueue = new MessageQueue(); + QueueLogRunner logRunner = new QueueLogRunner(mmLogQueue); + ITaskStatus loggingThreadStatus = BackgroundTask.Start(delegate + { + using StreamLogger streamLogger = new StreamLogger(new FileStream(logPath, FileMode.Create)); + streamLogger.Info("Log started at " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")); + logRunner.Run(streamLogger); + streamLogger.Info("Done!"); + }); + + // Wait for game database to be initialized for the 2nd time and wait for any plugins to initialize + yield return null; + yield return null; + + IBasicLogger mmLogger = new QueueLogger(mmLogQueue); + + IEnumerable modsAddedByAssemblies = ModListGenerator.GetAdditionalModsFromStaticMethods(mmLogger); + + IEnumerable databaseConfigs = null; + + MMPatchLoader patchLoader = new MMPatchLoader(modsAddedByAssemblies, mmLogger); + + ITaskStatus patchingThreadStatus = BackgroundTask.Start(delegate + { + databaseConfigs = patchLoader.Run(); + }); + + while(true) + { + yield return null; + + if (!patchingThreadStatus.IsRunning) + logRunner.RequestStop(); + + Status = patchLoader.status; + Errors = patchLoader.errors; + + if (!patchingThreadStatus.IsRunning && !loggingThreadStatus.IsRunning) break; + } + + if (patchingThreadStatus.IsExitedWithError) + { + kspLogger.Exception("The patching thread threw an exception", patchingThreadStatus.Exception); + FatalErrorHandler.HandleFatalError("The patching thread threw an exception"); + yield break; + } + + if (loggingThreadStatus.IsExitedWithError) + { + kspLogger.Exception("The logging thread threw an exception", loggingThreadStatus.Exception); + FatalErrorHandler.HandleFatalError("The logging thread threw an exception"); + yield break; + } + + if (databaseConfigs == null) + { + kspLogger.Error("The patcher returned a null collection of configs"); + FatalErrorHandler.HandleFatalError("The patcher returned a null collection of configs"); + yield break; + } + + PostPatchLoader.Instance.databaseConfigs = databaseConfigs; + } + } +} diff --git a/ModuleManager/ModListGenerator.cs b/ModuleManager/ModListGenerator.cs new file mode 100644 index 00000000..5d017232 --- /dev/null +++ b/ModuleManager/ModListGenerator.cs @@ -0,0 +1,243 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Diagnostics; +using System.Reflection; +using UnityEngine; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.Utils; +using ModuleManager.Progress; + +namespace ModuleManager +{ + public static class ModListGenerator + { + public static IEnumerable GenerateModList(IEnumerable modsAddedByAssemblies, IPatchProgress progress, IBasicLogger logger) + { + #region List of mods + + //string envInfo = "ModuleManager env info\n"; + //envInfo += " " + Environment.OSVersion.Platform + " " + ModuleManager.intPtr.ToInt64().ToString("X16") + "\n"; + //envInfo += " " + Convert.ToString(ModuleManager.intPtr.ToInt64(), 2) + " " + Convert.ToString(ModuleManager.intPtr.ToInt64() >> 63, 2) + "\n"; + //string gamePath = Environment.GetCommandLineArgs()[0]; + //envInfo += " Args: " + gamePath.Split(Path.DirectorySeparatorChar).Last() + " " + string.Join(" ", Environment.GetCommandLineArgs().Skip(1).ToArray()) + "\n"; + //envInfo += " Executable SHA256 " + FileSHA(gamePath); + // + //log(envInfo); + + List mods = new List(); + + StringBuilder modListInfo = new StringBuilder(); + + modListInfo.Append("compiling list of loaded mods...\nMod DLLs found:\n"); + + string format = " {0,-40}{1,-25}{2,-25}{3,-25}{4}\n"; + + modListInfo.AppendFormat( + format, + "Name", + "Assembly Version", + "Assembly File Version", + "KSPAssembly Version", + "SHA256" + ); + + modListInfo.Append('\n'); + + foreach (AssemblyLoader.LoadedAssembly mod in AssemblyLoader.loadedAssemblies) + { + + if (string.IsNullOrEmpty(mod.assembly.Location)) //Diazo Edit for xEvilReeperx AssemblyReloader mod + continue; + + FileVersionInfo fileVersionInfo = FileVersionInfo.GetVersionInfo(mod.assembly.Location); + + AssemblyName assemblyName = mod.assembly.GetName(); + + string kspAssemblyVersion; + if (mod.versionMajor == 0 && mod.versionMinor == 0) + kspAssemblyVersion = ""; + else + kspAssemblyVersion = mod.versionMajor + "." + mod.versionMinor; + + string fileSha = ""; + try + { + fileSha = FileUtils.FileSHA(mod.assembly.Location); + } + catch (Exception e) + { + progress.Exception("Exception while generating SHA for assembly " + assemblyName.Name, e); + } + + modListInfo.AppendFormat( + format, + assemblyName.Name, + assemblyName.Version, + fileVersionInfo.FileVersion, + kspAssemblyVersion, + fileSha + ); + + // modlist += String.Format(" {0,-50} SHA256 {1}\n", modInfo, FileSHA(mod.assembly.Location)); + + if (!mods.Contains(assemblyName.Name, StringComparer.OrdinalIgnoreCase)) + mods.Add(assemblyName.Name); + } + + modListInfo.Append("Non-DLL mods added (:FOR[xxx]):\n"); + foreach (UrlDir.UrlConfig cfgmod in GameDatabase.Instance.root.AllConfigs) + { + if (CommandParser.Parse(cfgmod.type, out string name) != Command.Insert) + { + if (name.Contains(":FOR[")) + { + name = name.RemoveWS(); + + // check for FOR[] blocks that don't match loaded DLLs and add them to the pass list + try + { + string dependency = name.Substring(name.IndexOf(":FOR[") + 5); + dependency = dependency.Substring(0, dependency.IndexOf(']')); + if (!mods.Contains(dependency, StringComparer.OrdinalIgnoreCase)) + { + // found one, now add it to the list. + mods.Add(dependency); + modListInfo.AppendFormat(" {0}\n", dependency); + } + } + catch (ArgumentOutOfRangeException) + { + progress.Error(cfgmod, "Skipping :FOR init for line " + name + + ". The line most likely contains a space that should be removed"); + } + } + } + } + modListInfo.Append("Mods by directory (sub directories of GameData):\n"); + UrlDir gameData = GameDatabase.Instance.root.children.First(dir => dir.type == UrlDir.DirectoryType.GameData); + foreach (UrlDir subDir in gameData.children) + { + string cleanName = subDir.name.RemoveWS(); + if (!mods.Contains(cleanName, StringComparer.OrdinalIgnoreCase)) + { + mods.Add(cleanName); + modListInfo.AppendFormat(" {0}\n", cleanName); + } + } + + modListInfo.Append("Mods added by assemblies:\n"); + foreach (ModAddedByAssembly mod in modsAddedByAssemblies) + { + if (!mods.Contains(mod.modName, StringComparer.OrdinalIgnoreCase)) + { + mods.Add(mod.modName); + modListInfo.AppendFormat(" {0}\n", mod); + } + } + + logger.Info(modListInfo.ToString()); + + mods.Sort(); + + #endregion List of mods + + return mods; + } + + public class ModAddedByAssembly + { + public readonly string modName; + public readonly string assemblyName; + + public ModAddedByAssembly(string modName, string assemblyName) + { + this.modName = modName ?? throw new ArgumentNullException(nameof(modName)); + this.assemblyName = assemblyName ?? throw new ArgumentNullException(nameof(assemblyName)); + } + + public override string ToString() + { + return $"{modName} (added by {assemblyName})"; + } + } + + public static IEnumerable GetAdditionalModsFromStaticMethods(IBasicLogger logger) + { + List result = new List(); + foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies()) + { + try + { + foreach (Type type in ass.GetTypes()) + { + MethodInfo method = type.GetMethod("ModuleManagerAddToModList", BindingFlags.Public | BindingFlags.Static); + + if (method != null && method.GetParameters().Length == 0 && typeof(IEnumerable).IsAssignableFrom(method.ReturnType)) + { + string methodName = $"{ass.GetName().Name}.{type.Name}.{method.Name}()"; + try + { + logger.Info("Calling " + methodName); + IEnumerable modsToAdd = (IEnumerable)method.Invoke(null, null); + + if (modsToAdd == null) + { + logger.Error("ModuleManagerAddToModList returned null: " + methodName); + continue; + } + + foreach (string mod in modsToAdd) + { + result.Add(new ModAddedByAssembly(mod, ass.GetName().Name)); + } + } + catch (Exception e) + { + logger.Exception("Exception while calling " + methodName, e); + } + } + } + } + catch (Exception e) + { + logger.Exception("Add to mod list threw an exception in loading " + ass.FullName, e); + } + } + + foreach (MonoBehaviour obj in UnityEngine.Object.FindObjectsOfType()) + { + MethodInfo method = obj.GetType().GetMethod("ModuleManagerAddToModList", BindingFlags.Public | BindingFlags.Instance); + + if (method != null && method.GetParameters().Length == 0 && typeof(IEnumerable).IsAssignableFrom(method.ReturnType)) + { + string methodName = $"{obj.GetType().Name}.{method.Name}()"; + try + { + logger.Info("Calling " + methodName); + IEnumerable modsToAdd = (IEnumerable)method.Invoke(obj, null); + + if (modsToAdd == null) + { + logger.Error("ModuleManagerAddToModList returned null: " + methodName); + continue; + } + + foreach (string mod in modsToAdd) + { + result.Add(new ModAddedByAssembly(mod, obj.GetType().Assembly.GetName().Name)); + } + } + catch (Exception e) + { + logger.Exception("Exception while calling " + methodName, e); + } + } + } + + return result; + } + } +} diff --git a/ModuleManager/ModuleManager.cs b/ModuleManager/ModuleManager.cs new file mode 100644 index 00000000..dd5e04e5 --- /dev/null +++ b/ModuleManager/ModuleManager.cs @@ -0,0 +1,593 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.IO; +using System.Linq; +using System.Reflection; +using TMPro; +using UnityEngine; +using Debug = UnityEngine.Debug; +using ModuleManager.Cats; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.UnityLogHandle; + +namespace ModuleManager +{ + [KSPAddon(KSPAddon.Startup.Instantly, true)] + public class ModuleManager : MonoBehaviour + { + #region state + + private bool inRnDCenter; + + public bool showUI = false; + private float textPos = 0; + + //private Texture2D tex; + //private Texture2D tex2; + + private bool nyan = false; + private bool nCats = false; + public static bool dumpPostPatch = false; + public static bool DontCopyLogs { get; private set; } = false; + + private PopupDialog menu; + + private MMPatchRunner patchRunner; + + #endregion state + + private static bool loadedInScene; + + internal void OnRnDCenterSpawn() + { + inRnDCenter = true; + } + + internal void OnRnDCenterDeSpawn() + { + inRnDCenter = false; + } + + public static void Log(String s) + { + print("[ModuleManager] " + s); + } + + private readonly Stopwatch totalTime = new Stopwatch(); + + internal void Awake() + { + if (LoadingScreen.Instance == null) + { + Destroy(gameObject); + return; + } + + // Ensure that only one copy of the service is run per scene change. + if (loadedInScene || !ElectionAndCheck()) + { + Assembly currentAssembly = Assembly.GetExecutingAssembly(); + Log("Multiple copies of current version. Using the first copy. Version: " + + currentAssembly.GetName().Version); + Destroy(gameObject); + return; + } + + totalTime.Start(); + + Debug.unityLogger.logHandler = new InterceptLogHandler(Debug.unityLogger.logHandler); + + // Allow loading the background in the loading screen + Application.runInBackground = true; + QualitySettings.vSyncCount = 0; + Application.targetFrameRate = -1; + + // More cool loading screen. Less 4 stoke logo. + for (int i = 0; i < LoadingScreen.Instance.Screens.Count; i++) + { + var state = LoadingScreen.Instance.Screens[i]; + state.fadeInTime = i < 3 ? 0.1f : 1; + state.displayTime = i < 3 ? 1 : 3; + state.fadeOutTime = i < 3 ? 0.1f : 1; + } + + TextMeshProUGUI[] texts = LoadingScreen.Instance.gameObject.GetComponentsInChildren(); + foreach (var text in texts) + { + textPos = Mathf.Min(textPos, text.rectTransform.localPosition.y); + } + DontDestroyOnLoad(gameObject); + + // Subscribe to the RnD center spawn/deSpawn events + GameEvents.onGUIRnDComplexSpawn.Add(OnRnDCenterSpawn); + GameEvents.onGUIRnDComplexDespawn.Add(OnRnDCenterDeSpawn); + + + LoadingScreen screen = FindObjectOfType(); + if (screen == null) + { + Log("Can't find LoadingScreen type. Aborting ModuleManager execution"); + return; + } + List list = LoadingScreen.Instance.loaders; + + if (list != null) + { + // So you can insert a LoadingSystem object in this list at any point. + // GameDatabase is first in the list, and PartLoader is second + // We could insert ModuleManager after GameDatabase to get it to run there + // and SaveGameFixer after PartLoader. + + int gameDatabaseIndex = list.FindIndex(s => s is GameDatabase); + + GameObject aGameObject = new GameObject("ModuleManager"); + DontDestroyOnLoad(aGameObject); + + Log(string.Format("Adding post patch to the loading screen {0}", list.Count)); + list.Insert(gameDatabaseIndex + 1, aGameObject.AddComponent()); + + patchRunner = new MMPatchRunner(new PrefixLogger("ModuleManager", new UnityLogger(Debug.unityLogger))); + StartCoroutine(patchRunner.Run()); + + // Workaround for 1.6.0 Editor bug after a PartDatabase rebuild. + if (Versioning.version_major == 1 && Versioning.version_minor == 6 && Versioning.Revision == 0) + { + Fix16 fix16 = aGameObject.AddComponent(); + list.Add(fix16); + } + } + + bool foolsDay = (DateTime.Now.Month == 4 && DateTime.Now.Day == 1); + bool catDay = (DateTime.Now.Month == 2 && DateTime.Now.Day == 22); + nyan = foolsDay + || Environment.GetCommandLineArgs().Contains("-nyan-nyan"); + + nCats = catDay + || Environment.GetCommandLineArgs().Contains("-ncats"); + + dumpPostPatch = Environment.GetCommandLineArgs().Contains("-mm-dump"); + + DontCopyLogs = Environment.GetCommandLineArgs().Contains("-mm-dont-copy-logs"); + + loadedInScene = true; + } + + private TextMeshProUGUI status; + private TextMeshProUGUI errors; + private TextMeshProUGUI warning; + + [SuppressMessage("Code Quality", "IDE0051", Justification = "Called by Unity")] + private void Start() + { + if (nCats) + CatManager.LaunchCats(); + else if (nyan) + CatManager.LaunchCat(); + + Canvas canvas = LoadingScreen.Instance.GetComponentInChildren(); + + status = CreateTextObject(canvas, "MMStatus"); + errors = CreateTextObject(canvas, "MMErrors"); + warning = CreateTextObject(canvas, "MMWarning"); + warning.text = ""; + + //if (Versioning.version_major == 1 && Versioning.version_minor == 0 && Versioning.Revision == 5 && Versioning.BuildID == 1024) + //{ + // warning.text = "Your KSP 1.0.5 is running on build 1024. You should upgrade to build 1028 to avoid problems with addons."; + // //if (GUI.Button(new Rect(Screen.width / 2f - 100, offsetY, 200, 20), "Click to open the Forum thread")) + // // Application.OpenURL("http://forum.kerbalspaceprogram.com/index.php?/topic/124998-silent-patch-for-ksp-105-published/"); + //} + + if (Versioning.version_major == 1 && Versioning.version_minor >= 8) + { + foreach (AssemblyLoader.LoadedAssembly assembly in AssemblyLoader.loadedAssemblies) + { + AssemblyName assemblyName = assembly.assembly.GetName(); + if (assemblyName.Name == "Firespitter" && assemblyName.Version <= Version.Parse("7.3.7175.38653")) + { + warning.text = "You are using a version of Firespitter that does not run properly on KSP 1.8+\nThis version may prevent the game from loading properly and may create problems for other mods"; + } + } + } + } + + private TextMeshProUGUI CreateTextObject(Canvas canvas, string name) + { + GameObject statusGameObject = new GameObject(name); + TextMeshProUGUI text = statusGameObject.AddComponent(); + text.text = "STATUS"; + text.fontSize = 18; + text.autoSizeTextContainer = true; + text.font = Resources.Load("Fonts/Calibri SDF", typeof(TMP_FontAsset)) as TMP_FontAsset; + text.alignment = TextAlignmentOptions.Center; + text.enableWordWrapping = false; + text.isOverlay = true; + text.rectTransform.anchorMin = new Vector2(0.5f, 0); + text.rectTransform.anchorMax = new Vector2(0.5f, 0); + text.rectTransform.anchoredPosition = Vector2.zero; + statusGameObject.transform.SetParent(canvas.transform); + + return text; + } + + // Unsubscribe from events when the behavior dies + internal void OnDestroy() + { + GameEvents.onGUIRnDComplexSpawn.Remove(OnRnDCenterSpawn); + GameEvents.onGUIRnDComplexDespawn.Remove(OnRnDCenterDeSpawn); + } + + internal void Update() + { + if (GameSettings.MODIFIER_KEY.GetKey() && Input.GetKeyDown(KeyCode.F11) + && (HighLogic.LoadedScene == GameScenes.SPACECENTER || HighLogic.LoadedScene == GameScenes.MAINMENU) + && !inRnDCenter) + { + if (menu == null) + { + menu = PopupDialog.SpawnPopupDialog(new Vector2(0.5f, 0.5f), + new Vector2(0.5f, 0.5f), + new MultiOptionDialog( + "ModuleManagerMenu", + "", + "ModuleManager", + HighLogic.UISkin, + new Rect(0.5f, 0.5f, 150f, 60f), + new DialogGUIFlexibleSpace(), + new DialogGUIVerticalLayout( + new DialogGUIFlexibleSpace(), + new DialogGUIButton("Reload Database", + delegate + { + MMPatchLoader.keepPartDB = false; + StartCoroutine(DataBaseReloadWithMM()); + }, 140.0f, 30.0f, true), + new DialogGUIButton("Quick Reload Database", + delegate + { + MMPatchLoader.keepPartDB = true; + StartCoroutine(DataBaseReloadWithMM()); + }, 140.0f, 30.0f, true), + new DialogGUIButton("Dump Database to Files", + delegate + { + StartCoroutine(DataBaseReloadWithMM(true)); + }, 140.0f, 30.0f, true), + new DialogGUIButton("Close", () => { }, 140.0f, 30.0f, true) + )), + false, + HighLogic.UISkin); + } + else + { + menu.Dismiss(); + menu = null; + } + } + + if (totalTime.IsRunning && HighLogic.LoadedScene == GameScenes.MAINMENU) + { + totalTime.Stop(); + Log("Total loading Time = " + ((float)totalTime.ElapsedMilliseconds / 1000).ToString("F3") + "s"); + + Application.runInBackground = GameSettings.SIMULATE_IN_BACKGROUND; + QualitySettings.vSyncCount = GameSettings.SYNC_VBL; + Application.targetFrameRate = GameSettings.FRAMERATE_LIMIT; + } + + float offsetY = textPos; + float h; + + if (patchRunner != null) + { + if (warning) + { + warning.text = InterceptLogHandler.Warnings; + h = warning.text.Length > 0 ? warning.textBounds.size.y : 0; + offsetY += h; + warning.rectTransform.localPosition = new Vector3(0, offsetY); + } + + if (status) + { + status.text = patchRunner.Status; + h = status.text.Length > 0 ? status.textBounds.size.y : 0; + offsetY += h; + status.transform.localPosition = new Vector3(0, offsetY); + } + + if (errors) + { + errors.text = patchRunner.Errors; + h = errors.text.Length > 0 ? errors.textBounds.size.y : 0; + offsetY += h; + errors.transform.localPosition = new Vector3(0, offsetY); + } + } + } + + #region GUI stuff. + + internal static IntPtr intPtr = new IntPtr(long.MaxValue); + /* Not required anymore. At least + public static bool IsABadIdea() + { + return (intPtr.ToInt64() == long.MaxValue) && (Environment.OSVersion.Platform == PlatformID.Win32NT); + } + */ + + private IEnumerator DataBaseReloadWithMM(bool dump = false) + { + QualitySettings.vSyncCount = 0; + Application.targetFrameRate = -1; + + patchRunner = new MMPatchRunner(new PrefixLogger("ModuleManager", new UnityLogger(Debug.unityLogger))); + + float totalLoadWeight = GameDatabase.Instance.LoadWeight() + PartLoader.Instance.LoadWeight(); + bool startedReload = false; + + UISkinDef skinDef = HighLogic.UISkin; + UIStyle centeredTextStyle = new UIStyle(skinDef.label) + { + alignment = TextAnchor.UpperCenter + }; + + PopupDialog reloadingDialog = PopupDialog.SpawnPopupDialog(new Vector2(0.5f, 0.5f), + new Vector2(0.5f, 0.5f), + new MultiOptionDialog( + "ModuleManagerReloading", + "", + "ModuleManager - Reloading Database", + skinDef, + new Rect(0.5f, 0.5f, 600f, 60f), + new DialogGUIFlexibleSpace(), + new DialogGUIVerticalLayout( + new DialogGUIFlexibleSpace(), + new DialogGUILabel(delegate () + { + float progressFraction; + if (!startedReload) + { + progressFraction = 0f; + } + else if (!GameDatabase.Instance.IsReady() || !PostPatchLoader.Instance.IsReady()) + { + progressFraction = GameDatabase.Instance.ProgressFraction() * GameDatabase.Instance.LoadWeight(); + progressFraction /= totalLoadWeight; + } + else if (!PartLoader.Instance.IsReady()) + { + progressFraction = GameDatabase.Instance.LoadWeight() + (PartLoader.Instance.ProgressFraction() * GameDatabase.Instance.LoadWeight()); + progressFraction /= totalLoadWeight; + } + else + { + progressFraction = 1f; + } + + return $"Overall progress: {progressFraction:P0}"; + }, centeredTextStyle, expandW: true), + new DialogGUILabel(delegate () + { + if (!startedReload) + return "Starting"; + else if (!GameDatabase.Instance.IsReady()) + return GameDatabase.Instance.ProgressTitle(); + else if (!PostPatchLoader.Instance.IsReady()) + return PostPatchLoader.Instance.ProgressTitle(); + else if (!PartLoader.Instance.IsReady()) + return PartLoader.Instance.ProgressTitle(); + else + return ""; + }), + new DialogGUISpace(5f), + new DialogGUILabel(() => patchRunner.Status) + ) + ), + false, + skinDef); + + yield return null; + + GameDatabase.Instance.Recompile = true; + GameDatabase.Instance.StartLoad(); + + startedReload = true; + + yield return null; + StartCoroutine(patchRunner.Run()); + + // wait for it to finish + while (!GameDatabase.Instance.IsReady()) + yield return null; + + PostPatchLoader.Instance.StartLoad(); + + while (!PostPatchLoader.Instance.IsReady()) + yield return null; + + if (dump) + OutputAllConfigs(); + + PartLoader.Instance.StartLoad(); + + while (!PartLoader.Instance.IsReady()) + yield return null; + + // Needs more work. + //ConfigNode game = HighLogic.CurrentGame.config.GetNode("GAME"); + + //if (game != null && ResearchAndDevelopment.Instance != null) + //{ + // ScreenMessages.PostScreenMessage("GAME found"); + // ConfigNode scenario = game.GetNodes("SCENARIO").FirstOrDefault((ConfigNode n) => n.name == "ResearchAndDevelopment"); + // if (scenario != null) + // { + // ScreenMessages.PostScreenMessage("SCENARIO found"); + // ResearchAndDevelopment.Instance.OnLoad(scenario); + // } + //} + + QualitySettings.vSyncCount = GameSettings.SYNC_VBL; + Application.targetFrameRate = GameSettings.FRAMERATE_LIMIT; + + reloadingDialog.Dismiss(); + } + + public static void OutputAllConfigs() + { + string path = Path.GetFullPath(Path.Combine(KSPUtil.ApplicationRootPath, "_MMCfgOutput")); + try + { + Directory.CreateDirectory(path); + foreach (string file in Directory.GetFiles(path)) + { + File.Delete(file); + } + foreach (string dir in Directory.GetDirectories(path)) + { + Directory.Delete(dir, true); + } + } + catch (IOException ioException) + { + Log("Exception while cleaning the export dir\n" + ioException); + } + catch (UnauthorizedAccessException unauthorizedAccessException) + { + Log("Exception while cleaning the export dir\n" + unauthorizedAccessException); + } + + static void WriteDirectoryRecursive(UrlDir currentDir, string dirPath) + { + if (currentDir.files.Count > 0) Directory.CreateDirectory(dirPath); + + foreach (UrlDir.UrlFile urlFile in currentDir.files) + { + if (urlFile.fileType != UrlDir.FileType.Config) continue; + + Log("Exporting " + urlFile.GetUrlWithExtension()); + string filePath = Path.Combine(dirPath, urlFile.GetNameWithExtension()); + + bool first = true; + + using FileStream stream = new FileStream(filePath, FileMode.Create); + using StreamWriter writer = new StreamWriter(stream); + foreach (UrlDir.UrlConfig urlConfig in urlFile.configs) + { + try + { + if (first) first = false; + else writer.Write("\n"); + + ConfigNode copy = urlConfig.config.DeepCopy(); + copy.EscapeValuesRecursive(); + writer.Write(copy.ToString()); + } + catch (Exception e) + { + Log("Exception while trying to write the file " + filePath + "\n" + e); + } + } + } + + foreach (UrlDir urlDir in currentDir.children) + { + WriteDirectoryRecursive(urlDir, Path.Combine(dirPath, urlDir.name)); + } + } + + try + { + WriteDirectoryRecursive(GameDatabase.Instance.root, path); + } + catch (DirectoryNotFoundException directoryNotFoundException) + { + Log("Exception while exporting the cfg\n" + directoryNotFoundException); + } + catch (IOException ioException) + { + Log("Exception while exporting the cfg\n" + ioException); + } + catch (UnauthorizedAccessException unauthorizedAccessException) + { + Log("Exception while exporting the cfg\n" + unauthorizedAccessException); + } + } + + #endregion GUI stuff. + + public bool ElectionAndCheck() + { + #region Type election + + // TODO : Move the old version check in a process that call Update. + + // Check for old version and MMSarbianExt + IEnumerable oldMM = + AssemblyLoader.loadedAssemblies.Where( + a => a.assembly.GetName().Name == Assembly.GetExecutingAssembly().GetName().Name) + .Where(a => a.assembly.GetName().Version.CompareTo(new System.Version(1, 5, 0)) == -1); + IEnumerable oldAssemblies = + oldMM.Concat(AssemblyLoader.loadedAssemblies.Where(a => a.assembly.GetName().Name == "MMSarbianExt")); + if (oldAssemblies.Any()) + { + IEnumerable badPaths = + oldAssemblies.Select(a => a.path) + .Select( + p => + Uri.UnescapeDataString( + new Uri(Path.GetFullPath(KSPUtil.ApplicationRootPath)).MakeRelativeUri(new Uri(p)) + .ToString() + .Replace('/', Path.DirectorySeparatorChar))); + string status = + "You have old versions of Module Manager (older than 1.5) or MMSarbianExt.\nYou will need to remove them for Module Manager and the mods using it to work\nExit KSP and delete those files :\n" + + String.Join("\n", badPaths.ToArray()); + PopupDialog.SpawnPopupDialog(new Vector2(0f, 1f), new Vector2(0f, 1f), "ModuleManagerOldVersions", "Old versions of Module Manager", status, "OK", false, UISkinManager.defaultSkin); + Log("Old version of Module Manager present. Stopping"); + return false; + } + + + //PopupDialog.SpawnPopupDialog(new Vector2(0.1f, 1f), new Vector2(0.2f, 1f), "Test of the dialog", "Stuff", "OK", false, UISkinManager.defaultSkin); + + Assembly currentAssembly = Assembly.GetExecutingAssembly(); + IEnumerable eligible = from a in AssemblyLoader.loadedAssemblies + let ass = a.assembly + where ass.GetName().Name == currentAssembly.GetName().Name + orderby ass.GetName().Version descending, a.path ascending + select a; + + // Elect the newest loaded version of MM to process all patch files. + // If there is a newer version loaded then don't do anything + // If there is a same version but earlier in the list, don't do anything either. + if (eligible.First().assembly != currentAssembly) + { + //loaded = true; + Log("version " + currentAssembly.GetName().Version + " at " + currentAssembly.Location + + " lost the election"); + Destroy(gameObject); + return false; + } + string candidates = ""; + foreach (AssemblyLoader.LoadedAssembly a in eligible) + { + if (currentAssembly.Location != a.path) + candidates += "Version " + a.assembly.GetName().Version + " " + a.path + " " + "\n"; + } + if (candidates.Length > 0) + { + Log("version " + currentAssembly.GetName().Version + " at " + currentAssembly.Location + + " won the election against\n" + candidates); + } + + #endregion Type election + + return true; + } + } +} diff --git a/ModuleManager/ModuleManager.csproj b/ModuleManager/ModuleManager.csproj new file mode 100644 index 00000000..20fe0da1 --- /dev/null +++ b/ModuleManager/ModuleManager.csproj @@ -0,0 +1,215 @@ + + + + Debug + AnyCPU + 10.0.0 + 2.0 + {02C8E3AF-69F9-4102-AB60-DD6DE60662D3} + Library + ModuleManager + ModuleManager + v4.7.1 + + + + True + full + False + bin\Debug\ + DEBUG; + prompt + 4 + False + default + false + + + none + True + bin\Release\ + prompt + 4 + False + false + + + 8.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + False + False + + + False + False + + + + + + False + False + + + False + False + + + False + False + + + False + False + + + False + False + + + False + False + + + False + False + + + False + False + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + sh -c "TARGET_PATH='$(TargetPath)' TARGET_DIR='$(TargetDir)' TARGET_NAME='$(TargetName)' sh '$(ProjectDir)/copy_build.sh'" + + \ No newline at end of file diff --git a/ModuleManager/ModuleManagerTestRunner.cs b/ModuleManager/ModuleManagerTestRunner.cs new file mode 100644 index 00000000..2f90a453 --- /dev/null +++ b/ModuleManager/ModuleManagerTestRunner.cs @@ -0,0 +1,75 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using ModuleManager.Extensions; +using ModuleManager.Logging; + +namespace ModuleManager +{ + public class InGameTestRunner + { + private readonly IBasicLogger logger; + + public InGameTestRunner(IBasicLogger logger) + { + this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public void RunTestCases(UrlDir gameDatabaseRoot) + { + if (gameDatabaseRoot == null) throw new ArgumentNullException(nameof(gameDatabaseRoot)); + logger.Info("Running tests..."); + + foreach (UrlDir.UrlConfig expect in gameDatabaseRoot.GetConfigs("MMTEST_EXPECT")) + { + // So for each of the expects, we expect all the configs before that node to match exactly. + UrlDir.UrlFile parent = expect.parent; + if (parent.configs.Count != expect.config.CountNodes + 1) + { + logger.Error("Test " + parent.name + " failed as expected number of nodes differs expected: " + + expect.config.CountNodes + " found: " + (parent.configs.Count - 1)); + for (int i = 0; i < parent.configs.Count; ++i) + logger.Info(parent.configs[i].config.ToString()); + continue; + } + for (int i = 0; i < expect.config.CountNodes; ++i) + { + ConfigNode gotNode = parent.configs[i].config; + ConfigNode expectNode = expect.config.nodes[i]; + if (!CompareRecursive(expectNode, gotNode)) + { + logger.Error("Test " + parent.name + "[" + i + + "] failed as expected output and actual output differ.\nexpected:\n" + expectNode + + "\nActually got:\n" + gotNode); + } + } + + // Purge the tests + parent.configs.Clear(); + } + logger.Info("tests complete."); + } + + private static bool CompareRecursive(ConfigNode expectNode, ConfigNode gotNode) + { + if (expectNode.values.Count != gotNode.values.Count || expectNode.nodes.Count != gotNode.nodes.Count) + return false; + for (int i = 0; i < expectNode.values.Count; ++i) + { + ConfigNode.Value eVal = expectNode.values[i]; + ConfigNode.Value gVal = gotNode.values[i]; + if (eVal.name != gVal.name || eVal.value != gVal.value) + return false; + } + for (int i = 0; i < expectNode.nodes.Count; ++i) + { + ConfigNode eNode = expectNode.nodes[i]; + ConfigNode gNode = gotNode.nodes[i]; + if (!CompareRecursive(eNode, gNode)) + return false; + } + return true; + } + } +} diff --git a/ModuleManager/NeedsChecker.cs b/ModuleManager/NeedsChecker.cs new file mode 100644 index 00000000..94f2ad29 --- /dev/null +++ b/ModuleManager/NeedsChecker.cs @@ -0,0 +1,188 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.Progress; +using NodeStack = ModuleManager.Collections.ImmutableStack; + +namespace ModuleManager +{ + public interface INeedsChecker + { + bool CheckNeeds(string mod); + bool CheckNeedsExpression(string needsString); + void CheckNeedsRecursive(ConfigNode node, UrlDir.UrlConfig urlConfig); + } + + public class NeedsChecker : INeedsChecker + { + private readonly IEnumerable mods; + private readonly UrlDir gameData; + private readonly IPatchProgress progress; + [SuppressMessage("CodeQuality", "IDE0052", Justification = "Reserved for future use")] + private readonly IBasicLogger logger; + + public NeedsChecker(IEnumerable mods, UrlDir gameData, IPatchProgress progress, IBasicLogger logger) + { + this.mods = mods ?? throw new ArgumentNullException(nameof(mods)); + this.gameData = gameData ?? throw new ArgumentNullException(nameof(gameData)); + this.progress = progress ?? throw new ArgumentNullException(nameof(progress)); + this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public bool CheckNeeds(string mod) + { + if (mod == null) throw new ArgumentNullException(nameof(mod)); + if (mod == string.Empty) throw new ArgumentException("can't be empty", nameof(mod)); + return mods.Contains(mod, StringComparer.InvariantCultureIgnoreCase); + } + + public bool CheckNeedsExpression(string needsExpression) + { + if (needsExpression == null) throw new ArgumentNullException(nameof(needsExpression)); + if (needsExpression == string.Empty) throw new ArgumentException("can't be empty", nameof(needsExpression)); + + foreach (string andDependencies in needsExpression.Split(',', '&')) + { + bool orMatch = false; + foreach (string orDependency in andDependencies.Split('|')) + { + if (orDependency.Length == 0) + continue; + + bool not = orDependency[0] == '!'; + string toFind = not ? orDependency.Substring(1) : orDependency; + + bool found = CheckNeedsWithDirectories(toFind); + + if (not == !found) + { + orMatch = true; + break; + } + } + if (!orMatch) + return false; + } + + return true; + } + + public void CheckNeedsRecursive(ConfigNode node, UrlDir.UrlConfig urlConfig) + { + if (node == null) throw new ArgumentNullException(nameof(node)); + if (urlConfig == null) throw new ArgumentNullException(nameof(urlConfig)); + CheckNeedsRecursive(new NodeStack(node), urlConfig); + } + + private bool CheckNeedsWithDirectories(string mod) + { + if (CheckNeeds(mod)) return true; + if (mod.Contains('/')) + { + string[] splits = mod.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries); + + bool result = true; + UrlDir current = gameData; + for (int i = 0; i < splits.Length; i++) + { + current = current.children.FirstOrDefault(dir => dir.name == splits[i]); + if (current == null) + { + result = false; + break; + } + } + return result; + } + return false; + } + + private bool CheckNeedsName(ref string name) + { + if (name == null) + return true; + + int idxStart = name.IndexOf(":NEEDS[", StringComparison.OrdinalIgnoreCase); + if (idxStart < 0) + return true; + int idxEnd = name.IndexOf(']', idxStart + 7); + string needsString = name.Substring(idxStart + 7, idxEnd - idxStart - 7); + + name = name.Substring(0, idxStart) + name.Substring(idxEnd + 1); + + return CheckNeedsExpression(needsString); + } + + private void CheckNeedsRecursive(NodeStack nodeStack, UrlDir.UrlConfig urlConfig) + { + ConfigNode original = nodeStack.value; + for (int i = 0; i < original.values.Count; ++i) + { + ConfigNode.Value val = original.values[i]; + string valname = val.name; + try + { + if (CheckNeedsName(ref valname)) + { + val.name = valname; + } + else + { + original.values.Remove(val); + i--; + progress.NeedsUnsatisfiedValue(urlConfig, nodeStack.GetPath() + '/' + val.name); + } + } + catch (ArgumentOutOfRangeException e) + { + progress.Exception("ArgumentOutOfRangeException in CheckNeeds for value \"" + val.name + "\"", e); + throw; + } + catch (Exception e) + { + progress.Exception("General Exception in CheckNeeds for value \"" + val.name + "\"", e); + throw; + } + } + + for (int i = 0; i < original.nodes.Count; ++i) + { + ConfigNode node = original.nodes[i]; + string nodeName = node.name; + + if (nodeName == null) + { + progress.Error(urlConfig, "Error - Node in file " + urlConfig.SafeUrl() + " subnode: " + nodeStack.GetPath() + " has config.name == null"); + } + + try + { + if (CheckNeedsName(ref nodeName)) + { + node.name = nodeName; + CheckNeedsRecursive(nodeStack.Push(node), urlConfig); + } + else + { + original.nodes.Remove(node); + i--; + progress.NeedsUnsatisfiedNode(urlConfig, nodeStack.GetPath() + '/' + node.name); + } + } + catch (ArgumentOutOfRangeException e) + { + progress.Exception("ArgumentOutOfRangeException in CheckNeeds for node \"" + node.name + "\"", e); + throw; + } + catch (Exception e) + { + progress.Exception("General Exception " + e.GetType().Name + " for node \"" + node.name + "\"", e); + throw; + } + } + } + } +} diff --git a/ModuleManager/NodeMatcher.cs b/ModuleManager/NodeMatcher.cs new file mode 100644 index 00000000..8777de97 --- /dev/null +++ b/ModuleManager/NodeMatcher.cs @@ -0,0 +1,58 @@ +using System; +using ModuleManager.Extensions; + +namespace ModuleManager +{ + public interface INodeMatcher + { + bool IsMatch(ConfigNode node); + } + + public class NodeMatcher : INodeMatcher + { + private readonly string type; + private readonly string[] namePatterns = null; + private readonly string constraints = ""; + + public NodeMatcher(string type, string name, string constraints) + { + if (type == string.Empty) throw new ArgumentException("can't be empty", nameof(type)); + this.type = type ?? throw new ArgumentNullException(nameof(type)); + + if (name == string.Empty) throw new ArgumentException("can't be empty (null allowed)", nameof(name)); + if (constraints == string.Empty) throw new ArgumentException("can't be empty (null allowed)", nameof(constraints)); + + if (name != null) namePatterns = name.Split(',', '|'); + if (constraints != null) + { + if (!constraints.IsBracketBalanced()) throw new ArgumentException("is not bracket balanced: " + constraints, nameof(constraints)); + this.constraints = constraints; + } + } + + public bool IsMatch(ConfigNode node) + { + if (node.name != type) return false; + + if (namePatterns != null) + { + string name = node.GetValue("name"); + if (name == null) return false; + + bool match = false; + foreach (string pattern in namePatterns) + { + if (MMPatchLoader.WildcardMatch(name, pattern)) + { + match = true; + break; + } + } + + if (!match) return false; + } + + return MMPatchLoader.CheckConstraints(node, constraints); + } + } +} diff --git a/ModuleManager/Operator.cs b/ModuleManager/Operator.cs new file mode 100644 index 00000000..2846efa6 --- /dev/null +++ b/ModuleManager/Operator.cs @@ -0,0 +1,15 @@ +using System; + +namespace ModuleManager +{ + public enum Operator + { + Assign, + Add, + Subtract, + Multiply, + Divide, + Exponentiate, + RegexReplace, + } +} diff --git a/ModuleManager/OperatorParser.cs b/ModuleManager/OperatorParser.cs new file mode 100644 index 00000000..e85eebab --- /dev/null +++ b/ModuleManager/OperatorParser.cs @@ -0,0 +1,57 @@ +using System; + +namespace ModuleManager +{ + public static class OperatorParser + { + public static Operator Parse(string name, out string valueName) + { + if (name == null) throw new ArgumentNullException(nameof(name)); + + if (name.Length == 0) + { + valueName = string.Empty; + return Operator.Assign; + } + else if (name.Length == 1 || (name[name.Length - 2] != ' ' && name[name.Length - 2] != '\t')) + { + valueName = name; + return Operator.Assign; + } + + Operator ret; + switch (name[name.Length - 1]) + { + case '+': + ret = Operator.Add; + break; + + case '-': + ret = Operator.Subtract; + break; + + case '*': + ret = Operator.Multiply; + break; + + case '/': + ret = Operator.Divide; + break; + + case '!': + ret = Operator.Exponentiate; + break; + + case '^': + ret = Operator.RegexReplace; + break; + + default: + valueName = name; + return Operator.Assign; + } + valueName = name.Substring(0, name.Length - 1).TrimEnd(); + return ret; + } + } +} diff --git a/ModuleManager/Pass.cs b/ModuleManager/Pass.cs new file mode 100644 index 00000000..c7db8684 --- /dev/null +++ b/ModuleManager/Pass.cs @@ -0,0 +1,32 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using ModuleManager.Patches; + +namespace ModuleManager +{ + public interface IPass : IEnumerable + { + string Name { get; } + } + + public class Pass : IPass + { + private readonly string name; + private readonly List patches = new List(0); + + public Pass(string name) + { + this.name = name ?? throw new ArgumentNullException(nameof(name)); + if (name == string.Empty) throw new ArgumentException("can't be empty", nameof(name)); + } + + public string Name => name; + + public void Add(IPatch patch) => patches.Add(patch); + + public List.Enumerator GetEnumerator() => patches.GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } +} diff --git a/ModuleManager/PatchApplier.cs b/ModuleManager/PatchApplier.cs new file mode 100644 index 00000000..adaade88 --- /dev/null +++ b/ModuleManager/PatchApplier.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; +using ModuleManager.Logging; +using ModuleManager.Extensions; +using ModuleManager.Patches; +using ModuleManager.Progress; + +namespace ModuleManager +{ + public class PatchApplier + { + private readonly IBasicLogger logger; + private readonly IPatchProgress progress; + + public PatchApplier(IPatchProgress progress, IBasicLogger logger) + { + this.progress = progress ?? throw new ArgumentNullException(nameof(progress)); + this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public IEnumerable ApplyPatches(IEnumerable patches) + { + if (patches == null) throw new ArgumentNullException(nameof(patches)); + + LinkedList databaseConfigs = new LinkedList(); + + foreach (IPass pass in patches) + { + ApplyPatches(databaseConfigs, pass); + } + + return databaseConfigs; + } + + private void ApplyPatches(LinkedList databaseConfigs, IPass pass) + { + progress.PassStarted(pass); + + foreach (IPatch patch in pass) + { + try + { + patch.Apply(databaseConfigs, progress, logger); + if (patch.CountsAsPatch) progress.PatchApplied(); + } + catch (Exception e) + { + progress.Exception(patch.UrlConfig, "Exception while processing node : " + patch.UrlConfig.SafeUrl(), e); + logger.Error("Processed node was\n" + patch.UrlConfig.PrettyPrint()); + } + } + } + } +} diff --git a/ModuleManager/PatchContext.cs b/ModuleManager/PatchContext.cs new file mode 100644 index 00000000..09e2f441 --- /dev/null +++ b/ModuleManager/PatchContext.cs @@ -0,0 +1,23 @@ +using System; +using System.Collections.Generic; +using ModuleManager.Logging; +using ModuleManager.Progress; + +namespace ModuleManager +{ + public struct PatchContext + { + public readonly UrlDir.UrlConfig patchUrl; + public readonly IEnumerable databaseConfigs; + public readonly IBasicLogger logger; + public readonly IPatchProgress progress; + + public PatchContext(UrlDir.UrlConfig patchUrl, IEnumerable databaseConfigs, IBasicLogger logger, IPatchProgress progress) + { + this.patchUrl = patchUrl; + this.databaseConfigs = databaseConfigs; + this.logger = logger; + this.progress = progress; + } + } +} diff --git a/ModuleManager/PatchExtractor.cs b/ModuleManager/PatchExtractor.cs new file mode 100644 index 00000000..6c8765f4 --- /dev/null +++ b/ModuleManager/PatchExtractor.cs @@ -0,0 +1,116 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.Patches; +using ModuleManager.Progress; +using ModuleManager.Tags; + +namespace ModuleManager +{ + public class PatchExtractor + { + private readonly IPatchProgress progress; + [SuppressMessage("CodeQuality", "IDE0052", Justification = "Reserved for future use")] + private readonly IBasicLogger logger; + private readonly INeedsChecker needsChecker; + private readonly ITagListParser tagListParser; + private readonly IProtoPatchBuilder protoPatchBuilder; + private readonly IPatchCompiler patchCompiler; + + public PatchExtractor( + IPatchProgress progress, + IBasicLogger logger, + INeedsChecker needsChecker, + ITagListParser tagListParser, + IProtoPatchBuilder protoPatchBuilder, + IPatchCompiler patchCompiler + ) + { + this.progress = progress ?? throw new ArgumentNullException(nameof(progress)); + this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); + this.needsChecker = needsChecker ?? throw new ArgumentNullException(nameof(needsChecker)); + this.tagListParser = tagListParser ?? throw new ArgumentNullException(nameof(tagListParser)); + this.protoPatchBuilder = protoPatchBuilder ?? throw new ArgumentNullException(nameof(protoPatchBuilder)); + this.patchCompiler = patchCompiler ?? throw new ArgumentNullException(nameof(patchCompiler)); + } + + public IPatch ExtractPatch(UrlDir.UrlConfig urlConfig) + { + if (urlConfig == null) throw new ArgumentNullException(nameof(urlConfig)); + + try + { + if (!urlConfig.type.IsBracketBalanced()) + { + progress.Error(urlConfig, "Error - node name does not have balanced brackets (or a space - if so replace with ?):\n" + urlConfig.SafeUrl()); + return null; + } + + Command command = CommandParser.Parse(urlConfig.type, out string name); + + if (command == Command.Replace) + { + progress.Error(urlConfig, $"Error - replace command (%) is not valid on a root node: {urlConfig.SafeUrl()}"); + return null; + } + else if (command == Command.Create) + { + progress.Error(urlConfig, $"Error - create command (&) is not valid on a root node: {urlConfig.SafeUrl()}"); + return null; + } + else if (command == Command.Rename) + { + progress.Error(urlConfig, $"Error - rename command (|) is not valid on a root node: {urlConfig.SafeUrl()}"); + return null; + } + else if (command == Command.Paste) + { + progress.Error(urlConfig, $"Error - paste command (#) is not valid on a root node: {urlConfig.SafeUrl()}"); + return null; + } + else if (command == Command.Special) + { + progress.Error(urlConfig, $"Error - special command (*) is not valid on a root node: {urlConfig.SafeUrl()}"); + return null; + } + + ITagList tagList; + try + { + tagList = tagListParser.Parse(name, urlConfig); + } + catch (FormatException ex) + { + progress.Error(urlConfig, $"Cannot parse node name as tag list: {ex.Message}\non: {urlConfig.SafeUrl()}"); + return null; + } + + ProtoPatch protoPatch = protoPatchBuilder.Build(urlConfig, command, tagList); + + if (protoPatch == null) + { + return null; + } + + if (protoPatch.needs != null && !needsChecker.CheckNeedsExpression(protoPatch.needs)) + { + progress.NeedsUnsatisfiedRoot(urlConfig); + return null; + } + else if (!protoPatch.passSpecifier.CheckNeeds(needsChecker, progress)) + { + return null; + } + + needsChecker.CheckNeedsRecursive(urlConfig.config, urlConfig); + return patchCompiler.CompilePatch(protoPatch); + } + catch(Exception e) + { + progress.Exception(urlConfig, $"Exception while attempting to create patch from config: {urlConfig.SafeUrl()}", e); + return null; + } + } + } +} diff --git a/ModuleManager/PatchList.cs b/ModuleManager/PatchList.cs new file mode 100644 index 00000000..d3990540 --- /dev/null +++ b/ModuleManager/PatchList.cs @@ -0,0 +1,138 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManager +{ + public class PatchList : IEnumerable + { + private class ModPass + { + public readonly string name; + public readonly Pass beforePass; + public readonly Pass forPass; + public readonly Pass afterPass; + public readonly Pass lastPass; + + public ModPass(string name) + { + if (name == null) throw new ArgumentNullException(nameof(name)); + if (name == string.Empty) throw new ArgumentException("can't be blank", nameof(name)); + this.name = name.ToUpperInvariant(); + + beforePass = new Pass($":BEFORE[{this.name}]"); + forPass = new Pass($":FOR[{this.name}]"); + afterPass = new Pass($":AFTER[{this.name}]"); + lastPass = new Pass($":LAST[{this.name}]"); + } + + public void AddBeforePatch(IPatch patch) => beforePass.Add(patch ?? throw new ArgumentNullException(nameof(patch))); + public void AddForPatch(IPatch patch) => forPass.Add(patch ?? throw new ArgumentNullException(nameof(patch))); + public void AddAfterPatch(IPatch patch) => afterPass.Add(patch ?? throw new ArgumentNullException(nameof(patch))); + public void AddLastPatch(IPatch patch) => lastPass.Add(patch ?? throw new ArgumentNullException(nameof(patch))); + } + + private readonly Pass insertPatches = new Pass(":INSERT (initial)"); + private readonly Pass firstPatches = new Pass(":FIRST"); + private readonly Pass legacyPatches = new Pass(":LEGACY (default)"); + private readonly Pass finalPatches = new Pass(":FINAL"); + + private readonly SortedDictionary modPasses = new SortedDictionary(StringComparer.InvariantCultureIgnoreCase); + private readonly SortedDictionary lastPasses = new SortedDictionary(StringComparer.InvariantCultureIgnoreCase); + + public PatchList(IEnumerable modList, IEnumerable patches, IPatchProgress progress) + { + if (modList == null) throw new ArgumentNullException(nameof(modList)); + if (patches == null) throw new ArgumentNullException(nameof(patches)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + + foreach (string mod in modList) + { + modPasses.Add(mod, new ModPass(mod)); + } + + foreach (IPatch patch in patches) + { + if (patch.PassSpecifier is InsertPassSpecifier) + { + insertPatches.Add(patch); + } + else if (patch.PassSpecifier is FirstPassSpecifier) + { + firstPatches.Add(patch); + } + else if (patch.PassSpecifier is LegacyPassSpecifier) + { + legacyPatches.Add(patch); + } + else if (patch.PassSpecifier is BeforePassSpecifier beforePassSpecifier) + { + EnsureMod(beforePassSpecifier.mod); + modPasses[beforePassSpecifier.mod].AddBeforePatch(patch); + } + else if (patch.PassSpecifier is ForPassSpecifier forPassSpecifier) + { + EnsureMod(forPassSpecifier.mod); + modPasses[forPassSpecifier.mod].AddForPatch(patch); + } + else if (patch.PassSpecifier is AfterPassSpecifier afterPassSpecifier) + { + EnsureMod(afterPassSpecifier.mod); + modPasses[afterPassSpecifier.mod].AddAfterPatch(patch); + } + else if (patch.PassSpecifier is LastPassSpecifier lastPassSpecifier) + { + if (!lastPasses.TryGetValue(lastPassSpecifier.mod, out Pass thisPass)) + { + thisPass = new Pass($":LAST[{lastPassSpecifier.mod.ToUpperInvariant()}]"); + lastPasses.Add(lastPassSpecifier.mod.ToLowerInvariant(), thisPass); + } + thisPass.Add(patch); + } + else if (patch.PassSpecifier is FinalPassSpecifier) + { + finalPatches.Add(patch); + } + else + { + throw new NotImplementedException("Don't know what to do with pass specifier: " + patch.PassSpecifier.Descriptor); + } + + if (patch.CountsAsPatch) progress.PatchAdded(); + } + } + + public IEnumerator GetEnumerator() + { + yield return insertPatches; + yield return firstPatches; + yield return legacyPatches; + + foreach (ModPass modPass in modPasses.Values) + { + yield return modPass.beforePass; + yield return modPass.forPass; + yield return modPass.afterPass; + } + + foreach (Pass lastPass in lastPasses.Values) + { + yield return lastPass; + } + + yield return finalPatches; + } + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + private void EnsureMod(string mod) + { + if (mod == null) throw new ArgumentNullException(nameof(mod)); + if (mod == string.Empty) throw new ArgumentException("can't be empty", nameof(mod)); + if (!modPasses.ContainsKey(mod)) throw new KeyNotFoundException($"Mod '{mod}' not found"); + } + } +} diff --git a/ModuleManager/Patches/CopyPatch.cs b/ModuleManager/Patches/CopyPatch.cs new file mode 100644 index 00000000..45ee09fe --- /dev/null +++ b/ModuleManager/Patches/CopyPatch.cs @@ -0,0 +1,58 @@ +using System; +using System.Collections.Generic; +using NodeStack = ModuleManager.Collections.ImmutableStack; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManager.Patches +{ + public class CopyPatch : IPatch + { + public UrlDir.UrlConfig UrlConfig { get; } + public INodeMatcher NodeMatcher { get; } + public IPassSpecifier PassSpecifier { get; } + public bool CountsAsPatch => true; + + public CopyPatch(UrlDir.UrlConfig urlConfig, INodeMatcher nodeMatcher, IPassSpecifier passSpecifier) + { + UrlConfig = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig)); + NodeMatcher = nodeMatcher ?? throw new ArgumentNullException(nameof(nodeMatcher)); + PassSpecifier = passSpecifier ?? throw new ArgumentNullException(nameof(passSpecifier)); + } + + public void Apply(LinkedList databaseConfigs, IPatchProgress progress, IBasicLogger logger) + { + if (databaseConfigs == null) throw new ArgumentNullException(nameof(databaseConfigs)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + if (logger == null) throw new ArgumentNullException(nameof(logger)); + + PatchContext context = new PatchContext(UrlConfig, databaseConfigs, logger, progress); + + for (LinkedListNode listNode = databaseConfigs.First; listNode != null; listNode = listNode.Next) + { + IProtoUrlConfig protoConfig = listNode.Value; + try + { + if (!NodeMatcher.IsMatch(protoConfig.Node)) continue; + + ConfigNode clone = MMPatchLoader.ModifyNode(new NodeStack(protoConfig.Node), UrlConfig.config, context); + if (protoConfig.Node.GetValue("name") is string name && name == clone.GetValue("name")) + { + progress.Error(UrlConfig, $"Error - when applying copy {UrlConfig.SafeUrl()} to {protoConfig.FullUrl} - the copy needs to have a different name than the parent (use @name = xxx)"); + } + else + { + progress.ApplyingCopy(protoConfig, UrlConfig); + listNode = databaseConfigs.AddAfter(listNode, new ProtoUrlConfig(protoConfig.UrlFile, clone)); + } + } + catch (Exception ex) + { + progress.Exception(UrlConfig, $"Exception while applying copy {UrlConfig.SafeUrl()} to {protoConfig.FullUrl}", ex); + } + } + } + } +} diff --git a/ModuleManager/Patches/DeletePatch.cs b/ModuleManager/Patches/DeletePatch.cs new file mode 100644 index 00000000..46d46a94 --- /dev/null +++ b/ModuleManager/Patches/DeletePatch.cs @@ -0,0 +1,51 @@ +using System; +using System.Collections.Generic; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManager.Patches +{ + public class DeletePatch : IPatch + { + public UrlDir.UrlConfig UrlConfig { get; } + public INodeMatcher NodeMatcher { get; } + public IPassSpecifier PassSpecifier { get; } + public bool CountsAsPatch => true; + + public DeletePatch(UrlDir.UrlConfig urlConfig, INodeMatcher nodeMatcher, IPassSpecifier passSpecifier) + { + UrlConfig = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig)); + NodeMatcher = nodeMatcher ?? throw new ArgumentNullException(nameof(nodeMatcher)); + PassSpecifier = passSpecifier ?? throw new ArgumentNullException(nameof(passSpecifier)); + } + + public void Apply(LinkedList databaseConfigs, IPatchProgress progress, IBasicLogger logger) + { + if (databaseConfigs == null) throw new ArgumentNullException(nameof(databaseConfigs)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + if (logger == null) throw new ArgumentNullException(nameof(logger)); + + LinkedListNode currentNode = databaseConfigs.First; + while (currentNode != null) + { + IProtoUrlConfig protoConfig = currentNode.Value; + try + { + LinkedListNode nextNode = currentNode.Next; + if (NodeMatcher.IsMatch(protoConfig.Node)) + { + progress.ApplyingDelete(protoConfig, UrlConfig); + databaseConfigs.Remove(currentNode); + } + currentNode = nextNode; + } + catch (Exception ex) + { + progress.Exception(UrlConfig, $"Exception while applying delete {UrlConfig.SafeUrl()} to {protoConfig.FullUrl}", ex); + } + } + } + } +} diff --git a/ModuleManager/Patches/EditPatch.cs b/ModuleManager/Patches/EditPatch.cs new file mode 100644 index 00000000..91613879 --- /dev/null +++ b/ModuleManager/Patches/EditPatch.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; +using NodeStack = ModuleManager.Collections.ImmutableStack; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManager.Patches +{ + public class EditPatch : IPatch + { + private readonly bool loop; + + public UrlDir.UrlConfig UrlConfig { get; } + public INodeMatcher NodeMatcher { get; } + public IPassSpecifier PassSpecifier { get; } + public bool CountsAsPatch => true; + + public EditPatch(UrlDir.UrlConfig urlConfig, INodeMatcher nodeMatcher, IPassSpecifier passSpecifier) + { + UrlConfig = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig)); + NodeMatcher = nodeMatcher ?? throw new ArgumentNullException(nameof(nodeMatcher)); + PassSpecifier = passSpecifier ?? throw new ArgumentNullException(nameof(passSpecifier)); + + loop = urlConfig.config.HasNode("MM_PATCH_LOOP"); + } + + public void Apply(LinkedList databaseConfigs, IPatchProgress progress, IBasicLogger logger) + { + if (databaseConfigs == null) throw new ArgumentNullException(nameof(databaseConfigs)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + if (logger == null) throw new ArgumentNullException(nameof(logger)); + + PatchContext context = new PatchContext(UrlConfig, databaseConfigs, logger, progress); + for (LinkedListNode listNode = databaseConfigs.First; listNode != null; listNode = listNode.Next) + { + IProtoUrlConfig protoConfig = listNode.Value; + try + { + if (!NodeMatcher.IsMatch(protoConfig.Node)) continue; + if (loop) logger.Info($"Looping on {UrlConfig.SafeUrl()} to {protoConfig.FullUrl}"); + + do + { + progress.ApplyingUpdate(protoConfig, UrlConfig); + listNode.Value = protoConfig = new ProtoUrlConfig(protoConfig.UrlFile, MMPatchLoader.ModifyNode(new NodeStack(protoConfig.Node), UrlConfig.config, context)); + } while (loop && NodeMatcher.IsMatch(protoConfig.Node)); + + if (loop) protoConfig.Node.RemoveNodes("MM_PATCH_LOOP"); + } + catch (Exception ex) + { + progress.Exception(UrlConfig, $"Exception while applying update {UrlConfig.SafeUrl()} to {protoConfig.FullUrl}", ex); + } + } + } + } +} diff --git a/ModuleManager/Patches/IPatch.cs b/ModuleManager/Patches/IPatch.cs new file mode 100644 index 00000000..a877ea80 --- /dev/null +++ b/ModuleManager/Patches/IPatch.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using ModuleManager.Logging; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManager.Patches +{ + public interface IPatch + { + UrlDir.UrlConfig UrlConfig { get; } + IPassSpecifier PassSpecifier { get; } + bool CountsAsPatch { get; } + void Apply(LinkedList configs, IPatchProgress progress, IBasicLogger logger); + } +} diff --git a/ModuleManager/Patches/InsertPatch.cs b/ModuleManager/Patches/InsertPatch.cs new file mode 100644 index 00000000..c5f2c17f --- /dev/null +++ b/ModuleManager/Patches/InsertPatch.cs @@ -0,0 +1,35 @@ +using System; +using System.Collections.Generic; +using ModuleManager.Extensions; +using ModuleManager.Logging; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManager.Patches +{ + public class InsertPatch : IPatch + { + public UrlDir.UrlConfig UrlConfig { get; } + public string NodeType { get; } + public IPassSpecifier PassSpecifier { get; } + public bool CountsAsPatch => false; + + public InsertPatch(UrlDir.UrlConfig urlConfig, string nodeType, IPassSpecifier passSpecifier) + { + UrlConfig = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig)); + NodeType = nodeType ?? throw new ArgumentNullException(nameof(nodeType)); + PassSpecifier = passSpecifier ?? throw new ArgumentNullException(nameof(passSpecifier)); + } + + public void Apply(LinkedList configs, IPatchProgress progress, IBasicLogger logger) + { + if (configs == null) throw new ArgumentNullException(nameof(configs)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + if (logger == null) throw new ArgumentNullException(nameof(logger)); + + ConfigNode node = UrlConfig.config.DeepCopy(); + node.name = NodeType; + configs.AddLast(new ProtoUrlConfig(UrlConfig.parent, node)); + } + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/AfterPassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/AfterPassSpecifier.cs new file mode 100644 index 00000000..a50b99c5 --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/AfterPassSpecifier.cs @@ -0,0 +1,29 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public class AfterPassSpecifier : IPassSpecifier + { + public readonly string mod; + public readonly UrlDir.UrlConfig urlConfig; + + public AfterPassSpecifier(string mod, UrlDir.UrlConfig urlConfig) + { + if (mod == string.Empty) throw new ArgumentException("can't be empty", nameof(mod)); + this.mod = mod ?? throw new ArgumentNullException(nameof(mod)); + this.urlConfig = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig)); + } + + public bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress) + { + if (needsChecker == null) throw new ArgumentNullException(nameof(needsChecker)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + bool result = needsChecker.CheckNeeds(mod); + if (!result) progress.NeedsUnsatisfiedAfter(urlConfig); + return result; + } + + public string Descriptor => $":AFTER[{mod.ToUpper()}]"; + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/BeforePassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/BeforePassSpecifier.cs new file mode 100644 index 00000000..9f509f43 --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/BeforePassSpecifier.cs @@ -0,0 +1,29 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public class BeforePassSpecifier : IPassSpecifier + { + public readonly string mod; + public readonly UrlDir.UrlConfig urlConfig; + + public BeforePassSpecifier(string mod, UrlDir.UrlConfig urlConfig) + { + if (mod == string.Empty) throw new ArgumentException("can't be empty", nameof(mod)); + this.mod = mod ?? throw new ArgumentNullException(nameof(mod)); + this.urlConfig = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig)); + } + + public bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress) + { + if (needsChecker == null) throw new ArgumentNullException(nameof(needsChecker)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + bool result = needsChecker.CheckNeeds(mod); + if (!result) progress.NeedsUnsatisfiedBefore(urlConfig); + return result; + } + + public string Descriptor => $":BEFORE[{mod.ToUpper()}]"; + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/FinalPassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/FinalPassSpecifier.cs new file mode 100644 index 00000000..7567f344 --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/FinalPassSpecifier.cs @@ -0,0 +1,17 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public class FinalPassSpecifier : IPassSpecifier + { + public bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress) + { + if (needsChecker == null) throw new ArgumentNullException(nameof(needsChecker)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + return true; + } + + public string Descriptor => ":FINAL"; + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/FirstPassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/FirstPassSpecifier.cs new file mode 100644 index 00000000..7d32bbbd --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/FirstPassSpecifier.cs @@ -0,0 +1,17 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public class FirstPassSpecifier : IPassSpecifier + { + public bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress) + { + if (needsChecker == null) throw new ArgumentNullException(nameof(needsChecker)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + return true; + } + + public string Descriptor => ":FIRST"; + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/ForPassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/ForPassSpecifier.cs new file mode 100644 index 00000000..3256a072 --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/ForPassSpecifier.cs @@ -0,0 +1,29 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public class ForPassSpecifier : IPassSpecifier + { + public readonly string mod; + public readonly UrlDir.UrlConfig urlConfig; + + public ForPassSpecifier(string mod, UrlDir.UrlConfig urlConfig) + { + if (mod == string.Empty) throw new ArgumentException("can't be empty", nameof(mod)); + this.mod = mod ?? throw new ArgumentNullException(nameof(mod)); + this.urlConfig = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig)); + } + + public bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress) + { + if (needsChecker == null) throw new ArgumentNullException(nameof(needsChecker)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + bool result = needsChecker.CheckNeeds(mod); + if (!result) progress.NeedsUnsatisfiedFor(urlConfig); + return result; + } + + public string Descriptor => $":FOR[{mod.ToUpper()}]"; + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/IPassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/IPassSpecifier.cs new file mode 100644 index 00000000..384e52d5 --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/IPassSpecifier.cs @@ -0,0 +1,11 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public interface IPassSpecifier + { + bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress); + string Descriptor { get; } + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/InsertPassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/InsertPassSpecifier.cs new file mode 100644 index 00000000..244f9c5c --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/InsertPassSpecifier.cs @@ -0,0 +1,17 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public class InsertPassSpecifier : IPassSpecifier + { + public bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress) + { + if (needsChecker == null) throw new ArgumentNullException(nameof(needsChecker)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + return true; + } + + public string Descriptor => ":INSERT (initial)"; + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/LastPassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/LastPassSpecifier.cs new file mode 100644 index 00000000..e0d4fcc4 --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/LastPassSpecifier.cs @@ -0,0 +1,19 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public class LastPassSpecifier : IPassSpecifier + { + public readonly string mod; + + public LastPassSpecifier(string mod) + { + if (mod == string.Empty) throw new ArgumentException("can't be empty", nameof(mod)); + this.mod = mod ?? throw new ArgumentNullException(nameof(mod)); + } + + public bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress) => true; + public string Descriptor => $":LAST[{mod.ToUpper()}]"; + } +} diff --git a/ModuleManager/Patches/PassSpecifiers/LegacyPassSpecifier.cs b/ModuleManager/Patches/PassSpecifiers/LegacyPassSpecifier.cs new file mode 100644 index 00000000..ddbee929 --- /dev/null +++ b/ModuleManager/Patches/PassSpecifiers/LegacyPassSpecifier.cs @@ -0,0 +1,17 @@ +using System; +using ModuleManager.Progress; + +namespace ModuleManager.Patches.PassSpecifiers +{ + public class LegacyPassSpecifier : IPassSpecifier + { + public bool CheckNeeds(INeedsChecker needsChecker, IPatchProgress progress) + { + if (needsChecker == null) throw new ArgumentNullException(nameof(needsChecker)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + return true; + } + + public string Descriptor => ":LEGACY (default)"; + } +} diff --git a/ModuleManager/Patches/PatchCompiler.cs b/ModuleManager/Patches/PatchCompiler.cs new file mode 100644 index 00000000..6c7e7f30 --- /dev/null +++ b/ModuleManager/Patches/PatchCompiler.cs @@ -0,0 +1,26 @@ +using System; + +namespace ModuleManager.Patches +{ + public interface IPatchCompiler + { + IPatch CompilePatch(ProtoPatch protoPatch); + } + + public class PatchCompiler : IPatchCompiler + { + public IPatch CompilePatch(ProtoPatch protoPatch) + { + if (protoPatch == null) throw new ArgumentNullException(nameof(protoPatch)); + + return protoPatch.command switch + { + Command.Insert => new InsertPatch(protoPatch.urlConfig, protoPatch.nodeType, protoPatch.passSpecifier), + Command.Edit => new EditPatch(protoPatch.urlConfig, new NodeMatcher(protoPatch.nodeType, protoPatch.nodeName, protoPatch.has), protoPatch.passSpecifier), + Command.Copy => new CopyPatch(protoPatch.urlConfig, new NodeMatcher(protoPatch.nodeType, protoPatch.nodeName, protoPatch.has), protoPatch.passSpecifier), + Command.Delete => new DeletePatch(protoPatch.urlConfig, new NodeMatcher(protoPatch.nodeType, protoPatch.nodeName, protoPatch.has), protoPatch.passSpecifier), + _ => throw new ArgumentException("has an invalid command for a root node: " + protoPatch.command, nameof(protoPatch)), + }; + } + } +} diff --git a/ModuleManager/Patches/ProtoPatch.cs b/ModuleManager/Patches/ProtoPatch.cs new file mode 100644 index 00000000..c1ad8572 --- /dev/null +++ b/ModuleManager/Patches/ProtoPatch.cs @@ -0,0 +1,27 @@ +using System; +using ModuleManager.Patches.PassSpecifiers; + +namespace ModuleManager.Patches +{ + public class ProtoPatch + { + public readonly UrlDir.UrlConfig urlConfig; + public readonly Command command; + public readonly string nodeType; + public readonly string nodeName; + public readonly string needs = null; + public readonly string has = null; + public readonly IPassSpecifier passSpecifier; + + public ProtoPatch(UrlDir.UrlConfig urlConfig, Command command, string nodeType, string nodeName, string needs, string has, IPassSpecifier passSpecifier) + { + this.urlConfig = urlConfig; + this.command = command; + this.nodeType = nodeType; + this.nodeName = nodeName; + this.needs = needs; + this.has = has; + this.passSpecifier = passSpecifier; + } + } +} diff --git a/ModuleManager/Patches/ProtoPatchBuilder.cs b/ModuleManager/Patches/ProtoPatchBuilder.cs new file mode 100644 index 00000000..377855fa --- /dev/null +++ b/ModuleManager/Patches/ProtoPatchBuilder.cs @@ -0,0 +1,247 @@ +using System; +using ModuleManager.Extensions; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; +using ModuleManager.Tags; + +namespace ModuleManager.Patches +{ + public interface IProtoPatchBuilder + { + ProtoPatch Build(UrlDir.UrlConfig urlConfig, Command command, ITagList tagList); + } + + public class ProtoPatchBuilder : IProtoPatchBuilder + { + private readonly IPatchProgress progress; + + public ProtoPatchBuilder(IPatchProgress progress) + { + this.progress = progress ?? throw new ArgumentNullException(nameof(progress)); + } + + public ProtoPatch Build(UrlDir.UrlConfig urlConfig, Command command, ITagList tagList) + { + if (urlConfig == null) throw new ArgumentNullException(nameof(urlConfig)); + if (tagList == null) throw new ArgumentNullException(nameof(tagList)); + if (progress == null) throw new ArgumentNullException(nameof(progress)); + + bool error = false; + + string nodeType = tagList.PrimaryTag.key; + string nodeName = tagList.PrimaryTag.value; + + if (command == Command.Insert && nodeName != null) + { + progress.Error(urlConfig, "name specifier detected on insert node (not a patch): " + urlConfig.SafeUrl()); + error = true; + } + + if (nodeName == string.Empty) + { + progress.Warning(urlConfig, "empty brackets detected on patch name: " + urlConfig.SafeUrl()); + nodeName = null; + } + + if (tagList.PrimaryTag.trailer != null) + progress.Warning(urlConfig, "unrecognized trailer: '" + tagList.PrimaryTag.trailer + "' on: " + urlConfig.SafeUrl()); + + string needs = null; + string has = null; + IPassSpecifier passSpecifier = null; + + foreach (Tag tag in tagList) + { + if (tag.trailer != null) + progress.Warning(urlConfig, "unrecognized trailer: '" + tag.trailer + "' on: " + urlConfig.SafeUrl()); + + if (tag.key.Equals("NEEDS", StringComparison.CurrentCultureIgnoreCase)) + { + if (needs != null) + { + progress.Warning(urlConfig, "more than one :NEEDS tag detected, ignoring all but the first: " + urlConfig.SafeUrl()); + continue; + } + if (string.IsNullOrEmpty(tag.value)) + { + progress.Error(urlConfig, "empty :NEEDS tag detected: " + urlConfig.SafeUrl()); + error = true; + continue; + } + + needs = tag.value; + } + else if (tag.key.Equals("HAS", StringComparison.CurrentCultureIgnoreCase)) + { + if (command == Command.Insert) + { + progress.Error(urlConfig, ":HAS detected on insert node (not a patch): " + urlConfig.SafeUrl()); + error = true; + continue; + } + if (has != null) + { + progress.Warning(urlConfig, "more than one :HAS tag detected, ignoring all but the first: " + urlConfig.SafeUrl()); + continue; + } + if (string.IsNullOrEmpty(tag.value)) + { + progress.Error(urlConfig, "empty :HAS tag detected: " + urlConfig.SafeUrl()); + error = true; + continue; + } + + has = tag.value; + } + else if (tag.key.Equals("FIRST", StringComparison.CurrentCultureIgnoreCase)) + { + if (tag.value != null) + { + progress.Warning(urlConfig, "value detected on :FIRST tag: " + urlConfig.SafeUrl()); + } + + if (command == Command.Insert) + { + progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl()); + error = true; + continue; + } + if (passSpecifier != null) + { + progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl()); + continue; + } + + passSpecifier = new FirstPassSpecifier(); + } + else if (tag.key.Equals("BEFORE", StringComparison.CurrentCultureIgnoreCase)) + { + if (string.IsNullOrEmpty(tag.value)) + { + progress.Error(urlConfig, "empty :BEFORE tag detected: " + urlConfig.SafeUrl()); + error = true; + continue; + } + + if (command == Command.Insert) + { + progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl()); + error = true; + continue; + } + if (passSpecifier != null) + { + progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl()); + continue; + } + + passSpecifier = new BeforePassSpecifier(tag.value, urlConfig); + } + else if (tag.key.Equals("FOR", StringComparison.CurrentCultureIgnoreCase)) + { + if (string.IsNullOrEmpty(tag.value)) + { + progress.Error(urlConfig, "empty :FOR tag detected: " + urlConfig.SafeUrl()); + error = true; + continue; + } + + if (command == Command.Insert) + { + progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl()); + error = true; + continue; + } + if (passSpecifier != null) + { + progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl()); + continue; + } + + passSpecifier = new ForPassSpecifier(tag.value, urlConfig); + } + else if (tag.key.Equals("AFTER", StringComparison.CurrentCultureIgnoreCase)) + { + if (string.IsNullOrEmpty(tag.value)) + { + progress.Error(urlConfig, "empty :AFTER tag detected: " + urlConfig.SafeUrl()); + error = true; + continue; + } + + if (command == Command.Insert) + { + progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl()); + error = true; + continue; + } + if (passSpecifier != null) + { + progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl()); + continue; + } + + passSpecifier = new AfterPassSpecifier(tag.value, urlConfig); + } + else if (tag.key.Equals("LAST", StringComparison.CurrentCultureIgnoreCase)) + { + if (string.IsNullOrEmpty(tag.value)) + { + progress.Error(urlConfig, "empty :LAST tag detected: " + urlConfig.SafeUrl()); + error = true; + continue; + } + + if (command == Command.Insert) + { + progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl()); + error = true; + continue; + } + if (passSpecifier != null) + { + progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl()); + continue; + } + + passSpecifier = new LastPassSpecifier(tag.value); + } + else if (tag.key.Equals("FINAL", StringComparison.CurrentCultureIgnoreCase)) + { + if (tag.value != null) + { + progress.Warning(urlConfig, "value detected on :FINAL tag: " + urlConfig.SafeUrl()); + } + + if (command == Command.Insert) + { + progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl()); + error = true; + continue; + } + if (passSpecifier != null) + { + progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl()); + continue; + } + + passSpecifier = new FinalPassSpecifier(); + } + else + { + progress.Warning(urlConfig, "unrecognized tag: '" + tag.key + "' on: " + urlConfig.SafeUrl()); + } + } + + if (error) return null; + + if (passSpecifier == null) + { + if (command == Command.Insert) passSpecifier = new InsertPassSpecifier(); + else passSpecifier = new LegacyPassSpecifier(); + } + + return new ProtoPatch(urlConfig, command, nodeType, nodeName, needs, has, passSpecifier); + } + } +} diff --git a/ModuleManager/PostPatchLoader.cs b/ModuleManager/PostPatchLoader.cs new file mode 100644 index 00000000..1bccce78 --- /dev/null +++ b/ModuleManager/PostPatchLoader.cs @@ -0,0 +1,231 @@ +using System; +using System.IO; +using System.Collections; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using UnityEngine; +using ModuleManager.Extensions; +using ModuleManager.Logging; + +using static ModuleManager.FilePathRepository; +using System.Diagnostics.CodeAnalysis; + +namespace ModuleManager +{ + public delegate void ModuleManagerPostPatchCallback(); + + public class PostPatchLoader : LoadingSystem + { + public static PostPatchLoader Instance { get; private set; } + + public IEnumerable databaseConfigs = null; + + private static readonly List postPatchCallbacks = new List(); + + private readonly IBasicLogger logger = new PrefixLogger("ModuleManager", new UnityLogger(UnityEngine.Debug.unityLogger)); + + private bool ready = false; + + private string progressTitle = "ModuleManager: Post patch"; + + public static void AddPostPatchCallback(ModuleManagerPostPatchCallback callback) + { + if (!postPatchCallbacks.Contains(callback)) + postPatchCallbacks.Add(callback); + } + + [SuppressMessage("CodeQuality", "IDE0051", Justification = "Called by Unity")] + private void Awake() + { + if (Instance != null) + { + Destroy(this); + return; + } + Instance = this; + } + + public override bool IsReady() => ready; + + public override float LoadWeight() => 0; + + public override float ProgressFraction() => 1; + + public override string ProgressTitle() => progressTitle; + + public override void StartLoad() + { + ready = false; + StartCoroutine(Run()); + } + + private IEnumerator Run() + { + Stopwatch waitTimer = new Stopwatch(); + waitTimer.Start(); + + progressTitle = "ModuleManager: Waiting for patching to finish"; + + while (databaseConfigs == null) yield return null; + + waitTimer.Stop(); + logger.Info("Waited " + ((float)waitTimer.ElapsedMilliseconds / 1000).ToString("F3") + "s for patching to finish"); + + Stopwatch postPatchTimer = new Stopwatch(); + postPatchTimer.Start(); + + progressTitle = "ModuleManager: Applying patched game database"; + logger.Info("Applying patched game database"); + + foreach (UrlDir.UrlFile file in GameDatabase.Instance.root.AllConfigFiles) + { + file.configs.Clear(); + } + + foreach (IProtoUrlConfig protoConfig in databaseConfigs) + { + protoConfig.UrlFile.AddConfig(protoConfig.Node); + } + + databaseConfigs = null; + + yield return null; + + if (File.Exists(logPath)) + { + if (ModuleManager.DontCopyLogs) + { + logger.Info("Not dumping log because -mm-dont-copy-logs was set"); + } + else + { + progressTitle = "ModuleManager: Dumping log to KSP log"; + logger.Info("Dumping ModuleManager log to main log"); + logger.Info("\n#### BEGIN MODULEMANAGER LOG ####\n\n\n" + File.ReadAllText(logPath) + "\n\n\n#### END MODULEMANAGER LOG ####"); + } + } + else + { + logger.Error("ModuleManager log does not exist: " + logPath); + } + + yield return null; + +#if DEBUG + InGameTestRunner testRunner = new InGameTestRunner(logger); + testRunner.RunTestCases(GameDatabase.Instance.root); +#endif + + yield return null; + + progressTitle = "ModuleManager: Reloading things"; + + logger.Info("Reloading resources definitions"); + PartResourceLibrary.Instance.LoadDefinitions(); + + logger.Info("Reloading Trait configs"); + GameDatabase.Instance.ExperienceConfigs.LoadTraitConfigs(); + + logger.Info("Reloading Part Upgrades"); + PartUpgradeManager.Handler.FillUpgrades(); + + LoadModdedPhysics(); + + yield return null; + + progressTitle = "ModuleManager: Running post patch callbacks"; + logger.Info("Running post patch callbacks"); + + foreach (ModuleManagerPostPatchCallback callback in postPatchCallbacks) + { + try + { + callback(); + } + catch (Exception e) + { + logger.Exception("Exception while running a post patch callback", e); + } + yield return null; + } + yield return null; + + // Call all "public static void ModuleManagerPostLoad()" on all class + foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies()) + { + try + { + foreach (Type type in ass.GetTypes()) + { + MethodInfo method = type.GetMethod("ModuleManagerPostLoad", BindingFlags.Public | BindingFlags.Static); + + if (method != null && method.GetParameters().Length == 0) + { + try + { + logger.Info("Calling " + ass.GetName().Name + "." + type.Name + "." + method.Name + "()"); + method.Invoke(null, null); + } + catch (Exception e) + { + logger.Exception("Exception while calling " + ass.GetName().Name + "." + type.Name + "." + method.Name + "()", e); + } + } + } + } + catch (Exception e) + { + logger.Exception("Post run call threw an exception in loading " + ass.FullName, e); + } + } + + yield return null; + + // Call "public void ModuleManagerPostLoad()" on all active MonoBehaviour instance + foreach (MonoBehaviour obj in FindObjectsOfType()) + { + MethodInfo method = obj.GetType().GetMethod("ModuleManagerPostLoad", BindingFlags.Public | BindingFlags.Instance); + + if (method != null && method.GetParameters().Length == 0) + { + try + { + logger.Info("Calling " + obj.GetType().Name + "." + method.Name + "()"); + method.Invoke(obj, null); + } + catch (Exception e) + { + logger.Exception("Exception while calling " + obj.GetType().Name + "." + method.Name + "() :\n", e); + } + } + } + + yield return null; + + if (ModuleManager.dumpPostPatch) + ModuleManager.OutputAllConfigs(); + + postPatchTimer.Stop(); + logger.Info("Post patch ran in " + ((float)postPatchTimer.ElapsedMilliseconds / 1000).ToString("F3") + "s"); + + ready = true; + } + + private void LoadModdedPhysics() + { + if (!File.Exists(physicsPath)) + { + logger.Error("Physics file not found"); + return; + } + + logger.Info("Setting modded physics as the active one"); + + PhysicsGlobals.PhysicsDatabaseFilename = physicsPath; + + if (!PhysicsGlobals.Instance.LoadDatabase()) + logger.Error("Something went wrong while setting the active physics config."); + } + } +} diff --git a/ModuleManager/Progress/IPatchProgress.cs b/ModuleManager/Progress/IPatchProgress.cs new file mode 100644 index 00000000..46bcb2ad --- /dev/null +++ b/ModuleManager/Progress/IPatchProgress.cs @@ -0,0 +1,32 @@ +using System; + +namespace ModuleManager.Progress +{ + public interface IPatchProgress + { + ProgressCounter Counter { get; } + + float ProgressFraction { get; } + + EventVoid OnPatchApplied { get; } + EventData OnPassStarted { get; } + + void Warning(UrlDir.UrlConfig url, string message); + void Error(UrlDir.UrlConfig url, string message); + void Error(string message); + void Exception(string message, Exception exception); + void Exception(UrlDir.UrlConfig url, string message, Exception exception); + void NeedsUnsatisfiedRoot(UrlDir.UrlConfig url); + void NeedsUnsatisfiedNode(UrlDir.UrlConfig url, string path); + void NeedsUnsatisfiedValue(UrlDir.UrlConfig url, string path); + void NeedsUnsatisfiedBefore(UrlDir.UrlConfig url); + void NeedsUnsatisfiedFor(UrlDir.UrlConfig url); + void NeedsUnsatisfiedAfter(UrlDir.UrlConfig url); + void ApplyingCopy(IUrlConfigIdentifier original, UrlDir.UrlConfig patch); + void ApplyingDelete(IUrlConfigIdentifier original, UrlDir.UrlConfig patch); + void ApplyingUpdate(IUrlConfigIdentifier original, UrlDir.UrlConfig patch); + void PatchAdded(); + void PatchApplied(); + void PassStarted(IPass pass); + } +} diff --git a/ModuleManager/Progress/PatchProgress.cs b/ModuleManager/Progress/PatchProgress.cs new file mode 100644 index 00000000..61fd0d33 --- /dev/null +++ b/ModuleManager/Progress/PatchProgress.cs @@ -0,0 +1,164 @@ +using System; +using ModuleManager.Extensions; +using ModuleManager.Logging; + +namespace ModuleManager.Progress +{ + public class PatchProgress : IPatchProgress + { + public ProgressCounter Counter { get; private set; } + + private readonly IBasicLogger logger; + + public float ProgressFraction + { + get + { + if (Counter.totalPatches > 0) + return Counter.appliedPatches / (float)Counter.totalPatches; + return 0; + } + } + + public EventVoid OnPatchApplied { get; } = new EventVoid("OnPatchApplied"); + public EventData OnPassStarted { get; } = new EventData("OnPassStarted"); + + public PatchProgress(IBasicLogger logger) + { + this.logger = logger; + Counter = new ProgressCounter(); + } + + public PatchProgress(IPatchProgress progress, IBasicLogger logger) + { + this.logger = logger; + Counter = progress.Counter; + } + + public void PatchAdded() + { + Counter.totalPatches.Increment(); + } + + public void PassStarted(IPass pass) + { + if (pass == null) throw new ArgumentNullException(nameof(pass)); + logger.Info(pass.Name + " pass"); + OnPassStarted.Fire(pass); + } + + public void ApplyingUpdate(IUrlConfigIdentifier original, UrlDir.UrlConfig patch) + { + logger.Info($"Applying update {patch.SafeUrl()} to {original.FullUrl}"); + Counter.patchedNodes.Increment(); + } + + public void ApplyingCopy(IUrlConfigIdentifier original, UrlDir.UrlConfig patch) + { + logger.Info($"Applying copy {patch.SafeUrl()} to {original.FullUrl}"); + Counter.patchedNodes.Increment(); + } + + public void ApplyingDelete(IUrlConfigIdentifier original, UrlDir.UrlConfig patch) + { + logger.Info($"Applying delete {patch.SafeUrl()} to {original.FullUrl}"); + Counter.patchedNodes.Increment(); + } + + public void PatchApplied() + { + Counter.appliedPatches.Increment(); + OnPatchApplied.Fire(); + } + + public void NeedsUnsatisfiedRoot(UrlDir.UrlConfig url) + { + logger.Info($"Deleting root node in file {url.parent.url} node: {url.type} as it can't satisfy its NEEDS"); + Counter.needsUnsatisfied.Increment(); + } + + public void NeedsUnsatisfiedNode(UrlDir.UrlConfig url, string path) + { + logger.Info($"Deleting node in file {url.parent.url} subnode: {path} as it can't satisfy its NEEDS"); + } + + public void NeedsUnsatisfiedValue(UrlDir.UrlConfig url, string path) + { + logger.Info($"Deleting value in file {url.parent.url} value: {path} as it can't satisfy its NEEDS"); + } + + public void NeedsUnsatisfiedBefore(UrlDir.UrlConfig url) + { + logger.Info($"Deleting root node in file {url.parent.url} node: {url.type} as it can't satisfy its BEFORE"); + Counter.needsUnsatisfied.Increment(); + } + + public void NeedsUnsatisfiedFor(UrlDir.UrlConfig url) + { + logger.Warning($"Deleting root node in file {url.parent.url} node: {url.type} as it can't satisfy its FOR (this shouldn't happen)"); + Counter.needsUnsatisfied.Increment(); + } + + public void NeedsUnsatisfiedAfter(UrlDir.UrlConfig url) + { + logger.Info($"Deleting root node in file {url.parent.url} node: {url.type} as it can't satisfy its AFTER"); + Counter.needsUnsatisfied.Increment(); + } + + public void Warning(UrlDir.UrlConfig url, string message) + { + Counter.warnings.Increment(); + logger.Warning(message); + RecordWarningFile(url); + } + + public void Error(UrlDir.UrlConfig url, string message) + { + Counter.errors.Increment(); + logger.Error(message); + RecordErrorFile(url); + } + + public void Error(string message) + { + Counter.errors.Increment(); + logger.Error(message); + } + + public void Exception(string message, Exception exception) + { + Counter.exceptions.Increment(); + logger.Exception(message, exception); + } + + public void Exception(UrlDir.UrlConfig url, string message, Exception exception) + { + Exception(message, exception); + RecordErrorFile(url); + } + + private void RecordWarningFile(UrlDir.UrlConfig url) + { + string key = url.parent.GetUrlWithExtension(); + if (key[0] == '/') + key = key.Substring(1); + + if (Counter.warningFiles.ContainsKey(key)) + Counter.warningFiles[key] += 1; + else + Counter.warningFiles[key] = 1; + } + + private void RecordErrorFile(UrlDir.UrlConfig url) + { + string key = url.parent.GetUrlWithExtension(); + if (key[0] == '/') + key = key.Substring(1); + + if (Counter.errorFiles.ContainsKey(key)) + Counter.errorFiles[key] += 1; + else + Counter.errorFiles[key] = 1; + } + } +} diff --git a/ModuleManager/Progress/ProgressCounter.cs b/ModuleManager/Progress/ProgressCounter.cs new file mode 100644 index 00000000..7fc16627 --- /dev/null +++ b/ModuleManager/Progress/ProgressCounter.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using ModuleManager.Utils; + +namespace ModuleManager.Progress +{ + public class ProgressCounter + { + public readonly Counter totalPatches = new Counter(); + public readonly Counter appliedPatches = new Counter(); + public readonly Counter patchedNodes = new Counter(); + public readonly Counter warnings = new Counter(); + public readonly Counter errors = new Counter(); + public readonly Counter exceptions = new Counter(); + public readonly Counter needsUnsatisfied = new Counter(); + + public readonly Dictionary warningFiles = new Dictionary(); + public readonly Dictionary errorFiles = new Dictionary(); + } +} diff --git a/Properties/AssemblyInfo.cs b/ModuleManager/Properties/AssemblyInfo.cs similarity index 96% rename from Properties/AssemblyInfo.cs rename to ModuleManager/Properties/AssemblyInfo.cs index 8896a384..12a660e1 100644 --- a/Properties/AssemblyInfo.cs +++ b/ModuleManager/Properties/AssemblyInfo.cs @@ -17,7 +17,7 @@ // The form "{Major}.{Minor}.*" will automatically update the build and revision, // and "{Major}.{Minor}.{Build}.*" will update just the revision. -[assembly: AssemblyVersion("2.6.25")] +[assembly: AssemblyVersion("4.2.3")] [assembly: KSPAssembly("ModuleManager", 2, 5)] // The following attributes are used to specify the signing key for the assembly, diff --git a/Properties/Resources.Designer.cs b/ModuleManager/Properties/Resources.Designer.cs similarity index 51% rename from Properties/Resources.Designer.cs rename to ModuleManager/Properties/Resources.Designer.cs index 91db7ae0..43d089d5 100644 --- a/Properties/Resources.Designer.cs +++ b/ModuleManager/Properties/Resources.Designer.cs @@ -63,11 +63,111 @@ internal Resources() { /// /// Looks up a localized resource of type System.Byte[]. /// - internal static byte[] cat { + internal static byte[] cat1 { get { - object obj = ResourceManager.GetObject("cat", resourceCulture); + object obj = ResourceManager.GetObject("cat-1", resourceCulture); return ((byte[])(obj)); } } + + internal static byte[] cat2 + { + get + { + object obj = ResourceManager.GetObject("cat-2", resourceCulture); + return ((byte[])(obj)); + } + } + + internal static byte[] cat3 + { + get + { + object obj = ResourceManager.GetObject("cat-3", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat4 + { + get + { + object obj = ResourceManager.GetObject("cat-4", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat5 + { + get + { + object obj = ResourceManager.GetObject("cat-5", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat6 + { + get + { + object obj = ResourceManager.GetObject("cat-6", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat7 + { + get + { + object obj = ResourceManager.GetObject("cat-7", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat8 + { + get + { + object obj = ResourceManager.GetObject("cat-8", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat9 + { + get + { + object obj = ResourceManager.GetObject("cat-9", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat10 + { + get + { + object obj = ResourceManager.GetObject("cat-10", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat11 + { + get + { + object obj = ResourceManager.GetObject("cat-11", resourceCulture); + return ((byte[])(obj)); + } + } + internal static byte[] cat12 + { + get + { + object obj = ResourceManager.GetObject("cat-12", resourceCulture); + return ((byte[])(obj)); + } + } + + internal static byte[] rainbow + { + get + { + object obj = ResourceManager.GetObject("rainbow2", resourceCulture); + return ((byte[])(obj)); + } + } + } } diff --git a/Properties/Resources.resx b/ModuleManager/Properties/Resources.resx similarity index 68% rename from Properties/Resources.resx rename to ModuleManager/Properties/Resources.resx index 938b3351..f8a77f25 100644 --- a/Properties/Resources.resx +++ b/ModuleManager/Properties/Resources.resx @@ -118,7 +118,43 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - cat;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + cat-1.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-10.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-11.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-12.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-2.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-3.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-4.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-5.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-6.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-7.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-8.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + cat-9.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + rainbow2.png;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 \ No newline at end of file diff --git a/ModuleManager/Properties/cat-1.png b/ModuleManager/Properties/cat-1.png new file mode 100644 index 00000000..9e2e6d5f Binary files /dev/null and b/ModuleManager/Properties/cat-1.png differ diff --git a/ModuleManager/Properties/cat-10.png b/ModuleManager/Properties/cat-10.png new file mode 100644 index 00000000..0b06270c Binary files /dev/null and b/ModuleManager/Properties/cat-10.png differ diff --git a/ModuleManager/Properties/cat-11.png b/ModuleManager/Properties/cat-11.png new file mode 100644 index 00000000..2cbed255 Binary files /dev/null and b/ModuleManager/Properties/cat-11.png differ diff --git a/ModuleManager/Properties/cat-12.png b/ModuleManager/Properties/cat-12.png new file mode 100644 index 00000000..703df541 Binary files /dev/null and b/ModuleManager/Properties/cat-12.png differ diff --git a/ModuleManager/Properties/cat-2.png b/ModuleManager/Properties/cat-2.png new file mode 100644 index 00000000..5ab18188 Binary files /dev/null and b/ModuleManager/Properties/cat-2.png differ diff --git a/ModuleManager/Properties/cat-3.png b/ModuleManager/Properties/cat-3.png new file mode 100644 index 00000000..164c3034 Binary files /dev/null and b/ModuleManager/Properties/cat-3.png differ diff --git a/ModuleManager/Properties/cat-4.png b/ModuleManager/Properties/cat-4.png new file mode 100644 index 00000000..5db5a128 Binary files /dev/null and b/ModuleManager/Properties/cat-4.png differ diff --git a/ModuleManager/Properties/cat-5.png b/ModuleManager/Properties/cat-5.png new file mode 100644 index 00000000..2cbed255 Binary files /dev/null and b/ModuleManager/Properties/cat-5.png differ diff --git a/ModuleManager/Properties/cat-6.png b/ModuleManager/Properties/cat-6.png new file mode 100644 index 00000000..703df541 Binary files /dev/null and b/ModuleManager/Properties/cat-6.png differ diff --git a/ModuleManager/Properties/cat-7.png b/ModuleManager/Properties/cat-7.png new file mode 100644 index 00000000..9e2e6d5f Binary files /dev/null and b/ModuleManager/Properties/cat-7.png differ diff --git a/ModuleManager/Properties/cat-8.png b/ModuleManager/Properties/cat-8.png new file mode 100644 index 00000000..5e3caa54 Binary files /dev/null and b/ModuleManager/Properties/cat-8.png differ diff --git a/ModuleManager/Properties/cat-9.png b/ModuleManager/Properties/cat-9.png new file mode 100644 index 00000000..164c3034 Binary files /dev/null and b/ModuleManager/Properties/cat-9.png differ diff --git a/ModuleManager/Properties/rainbow2.png b/ModuleManager/Properties/rainbow2.png new file mode 100644 index 00000000..2b15ab2e Binary files /dev/null and b/ModuleManager/Properties/rainbow2.png differ diff --git a/ModuleManager/ProtoUrlConfig.cs b/ModuleManager/ProtoUrlConfig.cs new file mode 100644 index 00000000..71f39df3 --- /dev/null +++ b/ModuleManager/ProtoUrlConfig.cs @@ -0,0 +1,37 @@ +using System; + +namespace ModuleManager +{ + public interface IUrlConfigIdentifier + { + string FileUrl { get; } + string NodeType { get; } + string FullUrl { get; } + } + + public interface IProtoUrlConfig : IUrlConfigIdentifier + { + UrlDir.UrlFile UrlFile { get; } + ConfigNode Node { get; } + } + + public class ProtoUrlConfig : IProtoUrlConfig + { + public UrlDir.UrlFile UrlFile { get; } + public ConfigNode Node { get; } + public string FileUrl { get; } + public string NodeType => Node.name; + public string FullUrl { get; } + + public ProtoUrlConfig(UrlDir.UrlFile urlFile, ConfigNode node) + { + UrlFile = urlFile ?? throw new ArgumentNullException(nameof(urlFile)); + Node = node ?? throw new ArgumentNullException(nameof(node)); + FileUrl = UrlFile.url + '.' + urlFile.fileExtension; + FullUrl = FileUrl + '/' + Node.name; + + if (node.GetValue("name") is string nameValue) + FullUrl += '[' + nameValue + ']'; + } + } +} diff --git a/ModuleManager/Tags/Tag.cs b/ModuleManager/Tags/Tag.cs new file mode 100644 index 00000000..173058a9 --- /dev/null +++ b/ModuleManager/Tags/Tag.cs @@ -0,0 +1,34 @@ +using System; + +namespace ModuleManager.Tags +{ + public struct Tag + { + public readonly string key; + public readonly string value; + public readonly string trailer; + + public Tag(string key, string value, string trailer) + { + this.key = key ?? throw new ArgumentNullException(nameof(key)); + if (key == string.Empty) throw new ArgumentException("can't be empty", nameof(key)); + + if (value == null && trailer != null) + throw new ArgumentException("trailer must be null if value is null"); + + if (trailer == string.Empty) throw new ArgumentException("can't be empty (null allowed)", nameof(trailer)); + + this.value = value; + this.trailer = trailer; + } + + public override string ToString() + { + string s = "< '" + key + "' "; + if (value != null) s += "[ '" + value + "' ] "; + if (trailer != null) s += "'" + trailer + "' "; + s += ">"; + return s; + } + } +} diff --git a/ModuleManager/Tags/TagList.cs b/ModuleManager/Tags/TagList.cs new file mode 100644 index 00000000..0744c411 --- /dev/null +++ b/ModuleManager/Tags/TagList.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using ModuleManager.Collections; + +namespace ModuleManager.Tags +{ + public interface ITagList : IEnumerable + { + Tag PrimaryTag { get; } + } + + public class TagList : ITagList + { + private readonly Tag[] tags; + + public TagList(Tag primaryTag, IEnumerable tags) + { + PrimaryTag = primaryTag; + this.tags = tags?.ToArray() ?? throw new ArgumentNullException(nameof(tags)); + } + + public Tag PrimaryTag { get; private set; } + + public ArrayEnumerator GetEnumerator() => new ArrayEnumerator(tags); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } +} diff --git a/ModuleManager/Tags/TagListParser.cs b/ModuleManager/Tags/TagListParser.cs new file mode 100644 index 00000000..c9ff1eed --- /dev/null +++ b/ModuleManager/Tags/TagListParser.cs @@ -0,0 +1,175 @@ +using System; +using System.Collections.Generic; +using ModuleManager.Progress; + +namespace ModuleManager.Tags +{ + public interface ITagListParser + { + ITagList Parse(string ToParse, UrlDir.UrlConfig urlConfig); + } + + public class TagListParser : ITagListParser + { + private readonly IPatchProgress progress; + + public TagListParser(IPatchProgress progress) + { + this.progress = progress ?? throw new ArgumentNullException(nameof(progress)); + } + + public ITagList Parse(string toParse, UrlDir.UrlConfig urlConfig) + { + if (toParse == null) throw new ArgumentNullException(nameof(toParse)); + if (urlConfig == null) throw new ArgumentNullException(nameof(urlConfig)); + if (toParse.Length == 0) throw new FormatException("can't create tag list from empty string"); + if (toParse[0] == '[') throw new FormatException("can't create tag list beginning with ["); + if (toParse[0] == ':') throw new FormatException("can't create tag list beginning with :"); + + if (toParse[toParse.Length - 1] == ':') + { + progress.Warning(urlConfig, "trailing : detected"); + toParse = toParse.TrimEnd(':'); + } + + List tags = new List(); + Tag primaryTag = ParsePrimaryTag(toParse, ref tags, urlConfig); + return new TagList(primaryTag, tags); + } + + private Tag ParsePrimaryTag(string toParse, ref List tags, UrlDir.UrlConfig urlConfig) + { + for (int i = 1; i < toParse.Length; i++) + { + char c = toParse[i]; + + if (c == '[') + { + int j = ClosingBracketIndex(toParse, i + 1); + return ParsePrimaryTrailer(toParse, j + 1, ref tags, toParse.Substring(0, i), toParse.Substring(i + 1, j - i - 1), urlConfig); + } + else if (c == ':') + { + ParseTag(toParse, i + 1, ref tags, urlConfig); + return new Tag(toParse.Substring(0, i), null, null); + } + else if (c == ']') + { + throw new FormatException("encountered closing bracket in primary key"); + } + } + + return new Tag(toParse, null, null); + } + + private Tag ParsePrimaryTrailer(string toParse, int start, ref List tags, string primaryKey, string primaryValue, UrlDir.UrlConfig urlConfig) + { + for (int i = start; i < toParse.Length; i++) + { + char c = toParse[i]; + + if (c == ':') + { + string trailer = i == start ? null : toParse.Substring(start, i - start); + ParseTag(toParse, i + 1, ref tags, urlConfig); + return new Tag(primaryKey, primaryValue, trailer); + } + else if (c == '[') + { + throw new FormatException("encountered opening bracket in primary trailer"); + } + else if (c == ']') + { + throw new FormatException("encountered closing bracket in primary trailer"); + } + } + + string primaryTrailer = toParse.Length - start == 0 ? null : toParse.Substring(start); + return new Tag(primaryKey, primaryValue, primaryTrailer); + } + + private void ParseTag(string toParse, int start, ref List tags, UrlDir.UrlConfig urlConfig) + { + for (int i = start; i < toParse.Length; i++) + { + char c = toParse[i]; + + if (c == '[') + { + if (i == start) + throw new FormatException("tag can't start with ["); + + int j = ClosingBracketIndex(toParse, i + 1); + ParseTrailer(toParse, j + 1, ref tags, toParse.Substring(start, i - start), toParse.Substring(i + 1, j - i - 1), urlConfig); + return; + } + else if (c == ':') + { + if (i == start) + progress.Warning(urlConfig, "extra : detected"); + else + tags.Add(new Tag(toParse.Substring(start, i - start), null, null)); + + ParseTag(toParse, i + 1, ref tags, urlConfig); + return; + } + else if (c == ']') + { + throw new FormatException("encountered closing bracket in key"); + } + } + + tags.Add(new Tag(toParse.Substring(start), null, null)); + } + + private void ParseTrailer(string toParse, int start, ref List tags, string key, string value, UrlDir.UrlConfig urlConfig) + { + for (int i = start; i < toParse.Length; i++) + { + char c = toParse[i]; + + if (c == ':') + { + string trailer = i == start ? null : toParse.Substring(start, i - start); + tags.Add(new Tag(key, value, trailer)); + ParseTag(toParse, i + 1, ref tags, urlConfig); + return; + } + else if (c == '[') + { + throw new FormatException("encountered opening bracket in trailer"); + } + else if (c == ']') + { + throw new FormatException("encountered closing bracket in trailer"); + } + } + + string finalTrailer = toParse.Length - start == 0 ? null : toParse.Substring(start); + tags.Add(new Tag(key, value, finalTrailer)); + } + + private static int ClosingBracketIndex(string toParse, int start) + { + int bracketLevel = 0; + + for (int i = start; i < toParse.Length; i++) + { + char c = toParse[i]; + + if (c == '[') + { + bracketLevel++; + } + else if (c == ']') + { + bracketLevel--; + } + + if (bracketLevel == -1) return i; + } + + throw new FormatException("reached end of the tag list without encountering a close bracket"); + } + } +} diff --git a/ModuleManager/Threading/BackgroundTask.cs b/ModuleManager/Threading/BackgroundTask.cs new file mode 100644 index 00000000..64891c04 --- /dev/null +++ b/ModuleManager/Threading/BackgroundTask.cs @@ -0,0 +1,33 @@ +using System; +using System.Threading; + +namespace ModuleManager.Threading +{ + public static class BackgroundTask + { + public static ITaskStatus Start(Action action) + { + if (action == null) throw new ArgumentNullException(nameof(action)); + + TaskStatus status = new TaskStatus(); + + void RunAction() + { + try + { + action(); + status.Finished(); + } + catch (Exception ex) + { + status.Error(ex); + } + } + + Thread thread = new Thread(RunAction); + thread.Start(); + + return new TaskStatusWrapper(status); + } + } +} diff --git a/ModuleManager/Threading/ITaskStatus.cs b/ModuleManager/Threading/ITaskStatus.cs new file mode 100644 index 00000000..e60c76bd --- /dev/null +++ b/ModuleManager/Threading/ITaskStatus.cs @@ -0,0 +1,12 @@ +using System; + +namespace ModuleManager.Threading +{ + public interface ITaskStatus + { + bool IsRunning { get; } + bool IsFinished { get; } + bool IsExitedWithError { get; } + Exception Exception { get; } + } +} diff --git a/ModuleManager/Threading/TaskStatus.cs b/ModuleManager/Threading/TaskStatus.cs new file mode 100644 index 00000000..1d2c6b67 --- /dev/null +++ b/ModuleManager/Threading/TaskStatus.cs @@ -0,0 +1,53 @@ +using System; + +namespace ModuleManager.Threading +{ + public class TaskStatus : ITaskStatus + { + private readonly object lockObject = new object(); + + public bool IsRunning { get; private set; } = true; + public Exception Exception { get; private set; } = null; + + public bool IsFinished + { + get + { + lock (lockObject) + { + return !IsRunning && Exception == null; + } + } + } + + public bool IsExitedWithError + { + get + { + lock (lockObject) + { + return !IsRunning && Exception != null; + } + } + } + + public void Finished() + { + lock (lockObject) + { + if (!IsRunning) throw new InvalidOperationException("Task is not running"); + IsRunning = false; + } + } + + public void Error(Exception exception) + { + lock(lockObject) + { + if (!IsRunning) throw new InvalidOperationException("Task is not running"); + this.Exception = exception ?? throw new ArgumentNullException(nameof(exception)); + IsRunning = false; + } + } + } +} diff --git a/ModuleManager/Threading/TaskStatusWrapper.cs b/ModuleManager/Threading/TaskStatusWrapper.cs new file mode 100644 index 00000000..1750633c --- /dev/null +++ b/ModuleManager/Threading/TaskStatusWrapper.cs @@ -0,0 +1,19 @@ +using System; + +namespace ModuleManager.Threading +{ + public class TaskStatusWrapper : ITaskStatus + { + private readonly ITaskStatus inner; + + public TaskStatusWrapper(ITaskStatus inner) + { + this.inner = inner; + } + + public bool IsRunning => inner.IsRunning; + public bool IsFinished => inner.IsFinished; + public bool IsExitedWithError => inner.IsExitedWithError; + public Exception Exception => inner.Exception; + } +} diff --git a/ModuleManager/Utils/Counter.cs b/ModuleManager/Utils/Counter.cs new file mode 100644 index 00000000..dcafce53 --- /dev/null +++ b/ModuleManager/Utils/Counter.cs @@ -0,0 +1,21 @@ +using System; + +namespace ModuleManager.Utils +{ + public class Counter + { + public int Value { get; private set; } = 0; + + public void Increment() + { + Value++; + } + + public override string ToString() + { + return Value.ToString(); + } + + public static implicit operator int(Counter counter) => counter.Value; + } +} diff --git a/ModuleManager/Utils/FileUtils.cs b/ModuleManager/Utils/FileUtils.cs new file mode 100644 index 00000000..fcf04482 --- /dev/null +++ b/ModuleManager/Utils/FileUtils.cs @@ -0,0 +1,21 @@ +using System; +using System.IO; +using System.Security.Cryptography; +using ModuleManager.Extensions; + +namespace ModuleManager.Utils +{ + public static class FileUtils + { + public static string FileSHA(string filename) + { + if (!File.Exists(filename)) throw new FileNotFoundException("File does not exist", filename); + + using SHA256 sha = SHA256.Create(); + using FileStream fs = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); + byte[] data = sha.ComputeHash(fs); + + return data.ToHex(); + } + } +} diff --git a/ModuleManager/copy_build.sh b/ModuleManager/copy_build.sh new file mode 100644 index 00000000..8d9f1ad5 --- /dev/null +++ b/ModuleManager/copy_build.sh @@ -0,0 +1,45 @@ +if [ -z "${TARGET_PATH}" ] ; then + echo 'Expected $TARGET_PATH to be defined but it is not' >&2 + exit 1 +elif ! [ -f "${TARGET_PATH}" ] ; then + echo 'Expected $TARGET_PATH to be a file but it is not' >&2 + exit 1 +fi + +if [ -z "${TARGET_DIR}" ] ; then + echo 'Expected $TARGET_DIR to be defined but it is not' >&2 + exit 1 +elif ! [ -d "${TARGET_DIR}" ] ; then + echo 'Expected $TARGET_DIR to be a directory but it is not' >&2 + exit 1 +fi + +if [ -z "${TARGET_NAME}" ] ; then + echo 'Expected $TARGET_NAME to be defined but it is not' >&2 + exit 1 +fi + +if [ -z "${PDB2MDB}" ] ; then + echo '$PDB2MDB not found' +else + echo "Running '${PDB2MDB}'" + "${PDB2MDB}" "${TARGET_PATH}" +fi + +if [ -z "${KSPDIR}" ] ; then + echo '$KSPDIR not found' +else + if ! [ -d "${KSPDIR}" ] ; then + echo 'Expected $KSPDIR to point to a directory but it is not' >&2 + exit 1 + fi + if ! [ -d "${KSPDIR}/GameData" ] ; then + echo 'Expected $KSPDIR to contain a GameData subdirectory but it does not' >&2 + exit 1 + fi + echo "Copying to '${KSPDIR}'" + cp "${TARGET_PATH}" "${KSPDIR}/GameData/" + test -f "${TARGET_DIR}/${TARGET_NAME}.pdb" && cp "${TARGET_DIR}/${TARGET_NAME}.pdb" "${KSPDIR}/GameData/" + test -f "${TARGET_DIR}/${TARGET_NAME}.dll.mdb" && cp "${TARGET_DIR}/${TARGET_NAME}.dll.mdb" "${KSPDIR}/GameData/" + rm -f "${KSPDIR}/GameData/ModuleManager.ConfigCache" +fi diff --git a/ModuleManager/packages.config b/ModuleManager/packages.config new file mode 100644 index 00000000..a9f29a32 --- /dev/null +++ b/ModuleManager/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/ModuleManagerTests/Collections/ArrayEnumeratorTest.cs b/ModuleManagerTests/Collections/ArrayEnumeratorTest.cs new file mode 100644 index 00000000..7ba5cf64 --- /dev/null +++ b/ModuleManagerTests/Collections/ArrayEnumeratorTest.cs @@ -0,0 +1,147 @@ +using System; +using System.Collections.Generic; +using Xunit; +using ModuleManager.Collections; + +namespace ModuleManagerTests.Collections +{ + public class ArrayEnumeratorTest + { + [Fact] + public void Test__Constructor__ArrayNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new ArrayEnumerator(null); + }); + + Assert.Equal("array", ex.ParamName); + } + + [Fact] + public void Test__Constructor__StartIndex__Negative() + { + string[] arr = { "abc", "def", "ghi" }; + ArgumentException ex = Assert.Throws(delegate + { + new ArrayEnumerator(arr, -1); + }); + + Assert.Equal("startIndex", ex.ParamName); + Assert.Contains("must be non-negative (got -1)", ex.Message); + } + + [Fact] + public void Test__Constructor__StartIndex__TooLarge() + { + string[] arr = { "abc", "def", "ghi" }; + ArgumentException ex = Assert.Throws(delegate + { + new ArrayEnumerator(arr, 4); + }); + + Assert.Equal("startIndex", ex.ParamName); + Assert.Contains("must be less than or equal to array length (array length 3, startIndex 4)", ex.Message); + } + + [Fact] + public void Test__Constructor__Length__Negative() + { + string[] arr = { "abc", "def", "ghi" }; + ArgumentException ex = Assert.Throws(delegate + { + new ArrayEnumerator(arr, 1, -1); + }); + + Assert.Equal("length", ex.ParamName); + Assert.Contains("must be non-negative (got -1)", ex.Message); + } + + [Fact] + public void Test__Constructor__Length__TooLong() + { + string[] arr = { "abc", "def", "ghi" }; + ArgumentException ex = Assert.Throws(delegate + { + new ArrayEnumerator(arr, 1, 3); + }); + + Assert.Equal("length", ex.ParamName); + Assert.Contains("must fit within the string (array length 3, startIndex 1, length 3)", ex.Message); + } + + [Fact] + public void TestArrayEnumerator() + { + string[] arr = { "abc", "def", "ghi" }; + + IEnumerator enumerator = new ArrayEnumerator(arr); + + Assert.True(enumerator.MoveNext()); + Assert.Equal("abc", enumerator.Current); + Assert.True(enumerator.MoveNext()); + Assert.Equal("def", enumerator.Current); + Assert.True(enumerator.MoveNext()); + Assert.Equal("ghi", enumerator.Current); + Assert.False(enumerator.MoveNext()); + } + + [Fact] + public void TestArrayEnumerator__Reset() + { + string[] arr = { "abc", "def" }; + + IEnumerator enumerator = new ArrayEnumerator(arr); + + Assert.True(enumerator.MoveNext()); + Assert.Equal("abc", enumerator.Current); + Assert.True(enumerator.MoveNext()); + Assert.Equal("def", enumerator.Current); + Assert.False(enumerator.MoveNext()); + + enumerator.Reset(); + + Assert.True(enumerator.MoveNext()); + Assert.Equal("abc", enumerator.Current); + Assert.True(enumerator.MoveNext()); + Assert.Equal("def", enumerator.Current); + Assert.False(enumerator.MoveNext()); + } + + [Fact] + public void TestArrayEnumerator__Empty() + { + string[] arr = new string[0]; + IEnumerator enumerator = new ArrayEnumerator(arr); + Assert.False(enumerator.MoveNext()); + } + + [Fact] + public void TestArrayEnumerator__StartIndex() + { + string[] arr = { "abc", "def", "ghi" }; + + IEnumerator enumerator = new ArrayEnumerator(arr, 1); + + Assert.True(enumerator.MoveNext()); + Assert.Equal("def", enumerator.Current); + Assert.True(enumerator.MoveNext()); + Assert.Equal("ghi", enumerator.Current); + Assert.False(enumerator.MoveNext()); + } + + [Fact] + public void TestArrayEnumerator__StartIndex__Length() + { + string[] arr = { "abc", "def", "ghi", "jkl" }; + + IEnumerator enumerator = new ArrayEnumerator(arr, 1, 2); + + Assert.True(enumerator.MoveNext()); + Assert.Equal("def", enumerator.Current); + Assert.True(enumerator.MoveNext()); + Assert.Equal("ghi", enumerator.Current); + Assert.False(enumerator.MoveNext()); + } + } +} diff --git a/ModuleManagerTests/Collections/ImmutableStackTest.cs b/ModuleManagerTests/Collections/ImmutableStackTest.cs new file mode 100644 index 00000000..56265d45 --- /dev/null +++ b/ModuleManagerTests/Collections/ImmutableStackTest.cs @@ -0,0 +1,140 @@ +using System; +using System.Linq; +using Xunit; + +using ModuleManager.Collections; + +namespace ModuleManagerTests.Collections +{ + public class ImmutableStackTest + { + [Fact] + public void TestValue() + { + object obj = new object(); + ImmutableStack stack = new ImmutableStack(obj); + + Assert.Same(obj, stack.value); + } + + [Fact] + public void TestIsRoot() + { + ImmutableStack stack1 = new ImmutableStack(new object()); + ImmutableStack stack2 = stack1.Push(new object()); + + Assert.True(stack1.IsRoot); + Assert.False(stack2.IsRoot); + } + + [Fact] + public void TestRoot() + { + ImmutableStack stack1 = new ImmutableStack(new object()); + ImmutableStack stack2 = stack1.Push(new object()); + ImmutableStack stack3 = stack2.Push(new object()); + + Assert.Same(stack1, stack1.Root); + Assert.Same(stack1, stack2.Root); + Assert.Same(stack1, stack3.Root); + } + + [Fact] + public void TestDepth() + { + ImmutableStack stack1 = new ImmutableStack(new object()); + ImmutableStack stack2 = stack1.Push(new object()); + ImmutableStack stack3 = stack2.Push(new object()); + + Assert.Equal(1, stack1.Depth); + Assert.Equal(2, stack2.Depth); + Assert.Equal(3, stack3.Depth); + } + + [Fact] + public void TestPush() + { + object obj1 = new object(); + object obj2 = new object(); + object obj3 = new object(); + ImmutableStack stack1 = new ImmutableStack(obj1); + ImmutableStack stack2 = stack1.Push(obj2); + ImmutableStack stack3 = stack2.Push(obj3); + + Assert.Same(stack2, stack3.parent); + Assert.Same(stack1, stack2.parent); + + Assert.Same(obj1, stack1.value); + Assert.Same(obj2, stack2.value); + Assert.Same(obj3, stack3.value); + } + + [Fact] + public void TestPop() + { + object obj1 = new object(); + object obj2 = new object(); + object obj3 = new object(); + ImmutableStack stack = new ImmutableStack(obj1).Push(obj2).Push(obj3); + + Assert.Same(obj1, stack.Pop().Pop().value); + Assert.Same(obj2, stack.Pop().value); + Assert.Same(obj3, stack.value); + } + + [Fact] + public void TestPop__Root() + { + ImmutableStack stack = new ImmutableStack(new object()); + + Assert.Throws(delegate + { + stack.Pop(); + }); + } + + [Fact] + public void TestReplaceValue() + { + object obj1 = new object(); + object obj2 = new object(); + object obj3 = new object(); + ImmutableStack stack1 = new ImmutableStack(obj1); + ImmutableStack stack2 = stack1.Push(obj2); + + ImmutableStack stack3 = stack2.ReplaceValue(obj3); + + Assert.Same(obj3, stack3.value); + Assert.Same(stack1, stack3.parent); + } + + [Fact] + public void TestReplaceValue__Root() + { + object obj1 = new object(); + object obj2 = new object(); + ImmutableStack stack1 = new ImmutableStack(obj1); + + ImmutableStack stack2 = stack1.ReplaceValue(obj2); + + Assert.Same(obj2, stack2.value); + Assert.Null(stack2.parent); + } + + [Fact] + public void TestEnumerator() + { + object obj1 = new object(); + object obj2 = new object(); + object obj3 = new object(); + ImmutableStack stack = new ImmutableStack(obj1).Push(obj2).Push(obj3); + + object[] objs = stack.ToArray(); + + Assert.Equal(3, objs.Length); + Assert.Same(obj3, objs[0]); + Assert.Same(obj2, objs[1]); + Assert.Same(obj1, objs[2]); + } + } +} diff --git a/ModuleManagerTests/Collections/KeyValueCacheTest.cs b/ModuleManagerTests/Collections/KeyValueCacheTest.cs new file mode 100644 index 00000000..4fc5a9e6 --- /dev/null +++ b/ModuleManagerTests/Collections/KeyValueCacheTest.cs @@ -0,0 +1,53 @@ +using System; +using Xunit; +using ModuleManager.Collections; + +namespace ModuleManagerTests.Collections +{ + public class KeyValueCacheTest + { + [Fact] + public void TestFetch__CreateValueNull() + { + KeyValueCache cache = new KeyValueCache(); + ArgumentNullException ex = Assert.Throws(delegate + { + cache.Fetch(new object(), null); + }); + + Assert.Equal("createValue", ex.ParamName); + } + + [Fact] + public void TestFetch__KeyNotPresent() + { + object key = new object(); + object value = new object(); + KeyValueCache cache = new KeyValueCache(); + + object fetchedValue = cache.Fetch(key, () => value); + + Assert.Same(value, fetchedValue); + } + + [Fact] + public void TestFetch__KeyPresent() + { + object key = new object(); + object value = new object(); + KeyValueCache cache = new KeyValueCache(); + + cache.Fetch(key, () => value); + + bool called2ndTime = false; + object fetchedValue = cache.Fetch(key, delegate + { + called2ndTime = true; + return null; + }); + + Assert.Same(value, fetchedValue); + Assert.False(called2ndTime); + } + } +} diff --git a/ModuleManagerTests/Collections/MessageQueueTest.cs b/ModuleManagerTests/Collections/MessageQueueTest.cs new file mode 100644 index 00000000..baf35d20 --- /dev/null +++ b/ModuleManagerTests/Collections/MessageQueueTest.cs @@ -0,0 +1,53 @@ +using System; +using Xunit; +using ModuleManager.Collections; + +namespace ModuleManagerTests.Collections +{ + public class MessageQueueTest + { + private class TestClass { } + + private readonly MessageQueue queue = new MessageQueue(); + + [Fact] + public void Test__Empty() + { + Assert.Empty(queue); + } + + [Fact] + public void TestAdd() + { + TestClass o1 = new TestClass(); + TestClass o2 = new TestClass(); + TestClass o3 = new TestClass(); + + queue.Add(o1); + queue.Add(o2); + queue.Add(o3); + + Assert.Equal(new[] { o1, o2, o3 }, queue); + } + + [Fact] + public void TestTakeAll() + { + TestClass o1 = new TestClass(); + TestClass o2 = new TestClass(); + TestClass o3 = new TestClass(); + TestClass o4 = new TestClass(); + + queue.Add(o1); + queue.Add(o2); + queue.Add(o3); + + MessageQueue queue2 = Assert.IsType>(queue.TakeAll()); + + queue.Add(o4); + + Assert.Equal(new[] { o4 }, queue); + Assert.Equal(new[] { o1, o2, o3 }, queue2); + } + } +} diff --git a/ModuleManagerTests/CommandParserTest.cs b/ModuleManagerTests/CommandParserTest.cs new file mode 100644 index 00000000..fd5d729e --- /dev/null +++ b/ModuleManagerTests/CommandParserTest.cs @@ -0,0 +1,86 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Xunit; +using ModuleManager; + +namespace ModuleManagerTests +{ + public class CommandParserTest + { + [Fact] + public void TestParse__Insert() + { + Assert.Equal(Command.Insert, CommandParser.Parse("PART", out string newName)); + Assert.Equal("PART", newName); + } + + [Fact] + public void TestParse__Delete() + { + Assert.Equal(Command.Delete, CommandParser.Parse("!PART", out string newName1)); + Assert.Equal("PART", newName1); + Assert.Equal(Command.Delete, CommandParser.Parse("-PART", out string newName2)); + Assert.Equal("PART", newName2); + } + + [Fact] + public void TestParse__Edit() + { + Assert.Equal(Command.Edit, CommandParser.Parse("@PART", out string newName)); + Assert.Equal("PART", newName); + } + + [Fact] + public void TestParse__Replace() + { + Assert.Equal(Command.Replace, CommandParser.Parse("%PART", out string newName)); + Assert.Equal("PART", newName); + } + + [Fact] + public void TestParse__Copy() + { + Assert.Equal(Command.Copy, CommandParser.Parse("+PART", out string newName1)); + Assert.Equal("PART", newName1); + Assert.Equal(Command.Copy, CommandParser.Parse("$PART", out string newName2)); + Assert.Equal("PART", newName2); + } + + [Fact] + public void TestParse__Rename() + { + Assert.Equal(Command.Rename, CommandParser.Parse("|PART", out string newName)); + Assert.Equal("PART", newName); ; + } + + [Fact] + public void TestParse__Paste() + { + Assert.Equal(Command.Paste, CommandParser.Parse("#PART", out string newName)); + Assert.Equal("PART", newName); + } + + [Fact] + public void TestParse__Special() + { + Assert.Equal(Command.Special, CommandParser.Parse("*PART", out string newName)); + Assert.Equal("PART", newName); + } + + [Fact] + public void TestParse__Special__Chained() + { + Assert.Equal(Command.Special, CommandParser.Parse("*@PART", out string newName)); + Assert.Equal("@PART", newName); + } + + [Fact] + public void TestParse__Create() + { + Assert.Equal(Command.Create, CommandParser.Parse("&PART", out string newName)); + Assert.Equal("PART", newName); + } + } +} diff --git a/ModuleManagerTests/DummyTest.cs b/ModuleManagerTests/DummyTest.cs new file mode 100644 index 00000000..50783efd --- /dev/null +++ b/ModuleManagerTests/DummyTest.cs @@ -0,0 +1,14 @@ +using System; +using Xunit; + +namespace ModuleManagerTests +{ + public class DummyTest + { + [Fact] + public void PassingTest() + { + Assert.True(true); + } + } +} diff --git a/ModuleManagerTests/Extensions/ByteArrayExtensionsTest.cs b/ModuleManagerTests/Extensions/ByteArrayExtensionsTest.cs new file mode 100644 index 00000000..ee53dcc8 --- /dev/null +++ b/ModuleManagerTests/Extensions/ByteArrayExtensionsTest.cs @@ -0,0 +1,28 @@ +using System; +using Xunit; +using ModuleManager.Extensions; + +namespace ModuleManagerTests.Extensions +{ + public class ByteArrayExtensionsTest + { + [Fact] + public void TestToHex() + { + byte[] data = { 0x00, 0xff, 0x01, 0xfe, 0x02, 0xfd, 0x9a }; + + Assert.Equal("00ff01fe02fd9a", data.ToHex()); + } + + [Fact] + public void TestToHex__NullData() + { + ArgumentNullException ex = Assert.Throws(delegate + { + ByteArrayExtensions.ToHex(null); + }); + + Assert.Equal("data", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/Extensions/ConfigNodeExtensionsTest.cs b/ModuleManagerTests/Extensions/ConfigNodeExtensionsTest.cs new file mode 100644 index 00000000..471be9cb --- /dev/null +++ b/ModuleManagerTests/Extensions/ConfigNodeExtensionsTest.cs @@ -0,0 +1,339 @@ +using System; +using System.Text; +using Xunit; +using TestUtils; +using ModuleManager.Extensions; + +namespace ModuleManagerTests.Extensions +{ + public class ConfigNodeExtensionsTest + { + [Fact] + public void TestShallowCopyFrom() + { + ConfigNode fromNode = new TestConfigNode("SOME_NODE") + { + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE_1") + { + { "mno", "pqr" }, + new TestConfigNode("INNER_INNER_NODE_1"), + }, + new TestConfigNode("INNER_NODE_2") + { + { "stu", "vwx" }, + new TestConfigNode("INNER_INNER_NODE_2"), + }, + }; + + ConfigNode.Value value1 = fromNode.values[0]; + ConfigNode.Value value2 = fromNode.values[1]; + + ConfigNode innerNode1 = fromNode.nodes[0]; + ConfigNode innerNode2 = fromNode.nodes[1]; + + ConfigNode toNode = new TestConfigNode("SOME_OTHER_NODE") + { + { "value", "will be removed" }, + new TestConfigNode("NODE_WILL_BE_REMOVED"), + }; + + toNode.ShallowCopyFrom(fromNode); + + Assert.Equal("SOME_NODE", fromNode.name); + Assert.Equal("SOME_OTHER_NODE", toNode.name); + + Assert.Equal(2, fromNode.values.Count); + Assert.Equal(2, toNode.values.Count); + + Assert.Same(value1, fromNode.values[0]); + Assert.Same(value1, toNode.values[0]); + AssertValue("abc", "def", value1); + + Assert.Same(value2, fromNode.values[1]); + Assert.Same(value2, toNode.values[1]); + AssertValue("ghi", "jkl", value2); + + Assert.Equal(2, fromNode.nodes.Count); + Assert.Equal(2, toNode.nodes.Count); + + Assert.Same(innerNode1, fromNode.nodes[0]); + Assert.Same(innerNode1, toNode.nodes[0]); + Assert.Equal("INNER_NODE_1", innerNode1.name); + Assert.Equal(1, innerNode1.values.Count); + AssertValue("mno", "pqr", innerNode1.values[0]); + Assert.Equal(1, innerNode1.nodes.Count); + Assert.Equal("INNER_INNER_NODE_1", innerNode1.nodes[0].name); + Assert.Empty(innerNode1.nodes[0].values); + Assert.Empty(innerNode1.nodes[0].nodes); + + Assert.Same(innerNode2, fromNode.nodes[1]); + Assert.Same(innerNode2, toNode.nodes[1]); + Assert.Equal("INNER_NODE_2", innerNode2.name); + Assert.Equal(1, innerNode2.values.Count); + AssertValue("stu", "vwx", innerNode2.values[0]); + Assert.Equal(1, innerNode2.nodes.Count); + Assert.Equal("INNER_INNER_NODE_2", innerNode2.nodes[0].name); + Assert.Empty(innerNode2.nodes[0].values); + Assert.Empty(innerNode2.nodes[0].nodes); + } + + [Fact] + public void TestDeepCopy() + { + ConfigNode fromNode = new TestConfigNode("SOME_NODE") + { + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE_1") + { + { "mno", "pqr" }, + { "weird_values", "some\r\n\tstuff" }, + new TestConfigNode("INNER_INNER_NODE_1"), + }, + new TestConfigNode("INNER_NODE_2") + { + { "stu", "vwx" }, + new TestConfigNode("INNER_INNER_NODE_2"), + }, + }; + + ConfigNode toNode = fromNode.DeepCopy(); + + Assert.Equal("SOME_NODE", toNode.name); + + Assert.Equal(2, toNode.values.Count); + + Assert.NotSame(fromNode.values[0], toNode.values[0]); + AssertValue("abc", "def", toNode.values[0]); + + Assert.NotSame(fromNode.values[1], toNode.values[1]); + AssertValue("ghi", "jkl", toNode.values[1]); + + Assert.Equal(2, toNode.nodes.Count); + + ConfigNode innerNode1 = toNode.nodes[0]; + Assert.NotSame(fromNode.nodes[0], innerNode1); + Assert.Equal("INNER_NODE_1", innerNode1.name); + Assert.Equal(2, innerNode1.values.Count); + Assert.NotSame(fromNode.nodes[0].values[0], innerNode1.values[0]); + AssertValue("mno", "pqr", innerNode1.values[0]); + Assert.NotSame(fromNode.nodes[0].values[1], innerNode1.values[1]); + AssertValue("weird_values", "some\r\n\tstuff", innerNode1.values[1]); + Assert.Equal(1, toNode.nodes[0].nodes.Count); + Assert.NotSame(fromNode.nodes[0].nodes[0], innerNode1.nodes[0]); + Assert.Equal("INNER_INNER_NODE_1", innerNode1.nodes[0].name); + Assert.Empty(innerNode1.nodes[0].values); + Assert.Empty(innerNode1.nodes[0].nodes); + + ConfigNode innerNode2 = toNode.nodes[1]; + Assert.NotSame(fromNode.nodes[1], innerNode2); + Assert.Equal("INNER_NODE_2", innerNode2.name); + Assert.Equal(1, innerNode2.values.Count); + Assert.NotSame(fromNode.nodes[1].values[0], innerNode2.values[0]); + AssertValue("stu", "vwx", innerNode2.values[0]); + Assert.Equal(1, innerNode2.nodes.Count); + Assert.NotSame(fromNode.nodes[1].nodes[0], innerNode2.nodes[0]); + Assert.Equal("INNER_INNER_NODE_2", innerNode2.nodes[0].name); + Assert.Empty(innerNode2.nodes[0].values); + Assert.Empty(innerNode2.nodes[0].nodes); + } + + [Fact] + public void TestPrettyPrint() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE_1") + { + { "mno", "pqr" }, + new TestConfigNode("INNER_INNER_NODE_1"), + }, + new TestConfigNode("INNER_NODE_2") + { + { "stu", "vwx" }, + new TestConfigNode("INNER_INNER_NODE_2"), + }, + }; + + string expected = @" +XXSOME_NODE +XX{ +XX abc = def +XX ghi = jkl +XX INNER_NODE_1 +XX { +XX mno = pqr +XX INNER_INNER_NODE_1 +XX { +XX } +XX } +XX INNER_NODE_2 +XX { +XX stu = vwx +XX INNER_INNER_NODE_2 +XX { +XX } +XX } +XX} +".TrimStart().Replace("\r", null); + + StringBuilder sb = new StringBuilder(); + node.PrettyPrint(ref sb, "XX"); + + Assert.Equal(expected, sb.ToString()); + } + + [Fact] + public void TestPrettyPrint__NullNode() + { + ConfigNode node = null; + StringBuilder sb = new StringBuilder(); + node.PrettyPrint(ref sb, "XX"); + Assert.Equal("XX\n", sb.ToString()); + } + + [Fact] + public void TestPrettyPrint__NullStringBuilder() + { + ConfigNode node = new ConfigNode("NODE"); + StringBuilder sb = null; + Assert.Throws(delegate + { + node.PrettyPrint(ref sb, "XX"); + }); + } + + [Fact] + public void TestPrettyPrint__NullIndent() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE") + { + { "mno", "pqr" }, + }, + }; + + string expected = @" +SOME_NODE +{ + abc = def + ghi = jkl + INNER_NODE + { + mno = pqr + } +} +".TrimStart().Replace("\r", null); + + StringBuilder sb = new StringBuilder(); + node.PrettyPrint(ref sb, null); + Assert.Equal(expected, sb.ToString()); + } + + [Fact] + public void TestPrettyPrint__NullName() + { + ConfigNode node = new TestConfigNode() + { + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE") + { + { "mno", "pqr" }, + }, + }; + + node.name = null; + + string expected = @" +XX +XX{ +XX abc = def +XX ghi = jkl +XX INNER_NODE +XX { +XX mno = pqr +XX } +XX} +".TrimStart().Replace("\r", null); + + StringBuilder sb = new StringBuilder(); + node.PrettyPrint(ref sb, "XX"); + Assert.Equal(expected, sb.ToString()); + } + + [Fact] + public void TestAddValueSafe() + { + ConfigNode node = new TestConfigNode + { + { "key1", "value1" }, + }; + + node.AddValueSafe("weird_values", "some\r\n\tstuff"); + + Assert.Equal(2, node.values.Count); + AssertValue("key1", "value1", node.values[0]); + AssertValue("weird_values", "some\r\n\tstuff", node.values[1]); + } + + [Fact] + public void TestEscapeValuesRecursive() + { + ConfigNode node = new TestConfigNode + { + { "key1", "value1" }, + { "key2", "value\nwith\rescped\tchars" }, + new TestConfigNode("SUBNODE") + { + { "key3", "value\nwith\rescped\tchars2" }, + }, + }; + + node.EscapeValuesRecursive(); + + Assert.Equal(2, node.values.Count); + AssertValue("key1", "value1", node.values[0]); + AssertValue("key2", "value\\nwith\\rescped\\tchars", node.values[1]); + Assert.Equal(1, node.nodes.Count); + Assert.Equal(1, node.nodes[0].values.Count); + AssertValue("key3", "value\\nwith\\rescped\\tchars2", node.nodes[0].values[0]); + } + + [Fact] + public void TestUnescapeValuesRecursive() + { + ConfigNode node = new TestConfigNode + { + { "key1", "value1" }, + { "key2", "value\\nwith\\rescped\\tchars" }, + new TestConfigNode("SUBNODE") + { + { "key3", "value\\nwith\\rescped\\tchars2" }, + }, + }; + + node.UnescapeValuesRecursive(); + + Assert.Equal(2, node.values.Count); + AssertValue("key1", "value1", node.values[0]); + AssertValue("key2", "value\nwith\rescped\tchars", node.values[1]); + Assert.Equal(1, node.nodes.Count); + Assert.Equal(1, node.nodes[0].values.Count); + AssertValue("key3", "value\nwith\rescped\tchars2", node.nodes[0].values[0]); + } + + private void AssertValue(string name, string value, ConfigNode.Value nodeValue) + { + Assert.Equal(name, nodeValue.name); + Assert.Equal(value, nodeValue.value); + } + } +} diff --git a/ModuleManagerTests/Extensions/IBasicLoggerExtensionsTest.cs b/ModuleManagerTests/Extensions/IBasicLoggerExtensionsTest.cs new file mode 100644 index 00000000..74e82d88 --- /dev/null +++ b/ModuleManagerTests/Extensions/IBasicLoggerExtensionsTest.cs @@ -0,0 +1,83 @@ +using System; +using Xunit; +using NSubstitute; +using ModuleManager.Logging; +using ModuleManager.Extensions; + +namespace ModuleManagerTests.Extensions +{ + public class IBasicLoggerExtensionsTest + { + private readonly IBasicLogger logger = Substitute.For(); + + [Fact] + public void TestInfo() + { + logger.Info("well hi there"); + logger.AssertInfo("well hi there"); + } + + [Fact] + public void TestWarning() + { + logger.Warning("I'm warning you"); + logger.AssertWarning("I'm warning you"); + } + + [Fact] + public void TestError() + { + logger.Error("You have made a grave mistake"); + logger.AssertError("You have made a grave mistake"); + } + + [Fact] + public void TestException() + { + Exception ex = new Exception(); + logger.Exception(ex); + logger.AssertException(ex); + } + + [Fact] + public void TestException__Null() + { + ArgumentNullException ex = Assert.Throws(delegate + { + logger.Exception(null); + }); + + Assert.Equal("exception", ex.ParamName); + } + + [Fact] + public void TestException__Message() + { + Exception ex = new Exception(); + logger.Exception("a message", ex); + logger.AssertException("a message", ex); + } + + [Fact] + public void TestException__Message__MessageNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + logger.Exception(null, new Exception()); + }); + + Assert.Equal("message", ex.ParamName); + } + + [Fact] + public void TestException__Message__ExceptionNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + logger.Exception("a message", null); + }); + + Assert.Equal("exception", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/Extensions/NodeStackExtensionsTest.cs b/ModuleManagerTests/Extensions/NodeStackExtensionsTest.cs new file mode 100644 index 00000000..2539d10b --- /dev/null +++ b/ModuleManagerTests/Extensions/NodeStackExtensionsTest.cs @@ -0,0 +1,22 @@ +using System; +using Xunit; +using ModuleManager.Collections; +using ModuleManager.Extensions; + +namespace ModuleManagerTests.Extensions +{ + public class NodeStackExtensionsTest + { + [Fact] + public void TestGetPath() + { + ConfigNode node1 = new ConfigNode("NODE1"); + ConfigNode node2 = new ConfigNode("NODE2"); + ConfigNode node3 = new ConfigNode("NODE3"); + + ImmutableStack stack = new ImmutableStack(node1).Push(node2).Push(node3); + + Assert.Equal("NODE1/NODE2/NODE3", stack.GetPath()); + } + } +} diff --git a/ModuleManagerTests/Extensions/StringExtensionsTest.cs b/ModuleManagerTests/Extensions/StringExtensionsTest.cs new file mode 100644 index 00000000..acf9274e --- /dev/null +++ b/ModuleManagerTests/Extensions/StringExtensionsTest.cs @@ -0,0 +1,73 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Xunit; +using ModuleManager.Extensions; + +namespace ModuleManagerTests.Extensions +{ + public class StringExtensionsTest + { + [Fact] + public void TestIsBracketBalanced() + { + Assert.True("abc[def[ghi[jkl]mno[pqr]]stu]vwx".IsBracketBalanced()); + } + + [Fact] + public void TestIsBracketBalanced__NoBrackets() + { + Assert.True("she sells seashells by the seashore".IsBracketBalanced()); + } + + [Fact] + public void TestIsBracketBalanced__Unbalanced() + { + Assert.False("abc[def[ghi[jkl]mno[pqr]]stuvwx".IsBracketBalanced()); + Assert.False("abcdef[ghi[jkl]mno[pqr]]stu]vwx".IsBracketBalanced()); + } + + [Fact] + public void TestIsBracketBalanced__BalancedButNegative() + { + Assert.False("abc]def[ghi".IsBracketBalanced()); + } + + [Fact] + public void TestRemoveWS() + { + Assert.Equal("abcdef", " abc \tdef\r\n\t ".RemoveWS()); + } + + + [InlineData("abc", "b", true, 1)] + [InlineData("abc", "x", false, -1)] + [Theory] + public void TestContains(string str, string test, bool expectedResult, int expectedIndex) + { + bool result = str.Contains(test, out int index); + Assert.Equal(expectedResult, result); + Assert.Equal(expectedIndex, index); + } + + [Fact] + public void TestContains__NullStr() + { + string s = null; + Assert.Throws(delegate + { + s.Contains("x", out int _x); + }); + } + + [Fact] + public void TestContains__NullValue() + { + Assert.Throws(delegate + { + "abc".Contains(null, out int _x); + }); + } + } +} diff --git a/ModuleManagerTests/Extensions/UrlConfigExtensionsTest.cs b/ModuleManagerTests/Extensions/UrlConfigExtensionsTest.cs new file mode 100644 index 00000000..953edfe9 --- /dev/null +++ b/ModuleManagerTests/Extensions/UrlConfigExtensionsTest.cs @@ -0,0 +1,227 @@ +using System; +using Xunit; +using TestUtils; +using ModuleManager.Extensions; + +namespace ModuleManagerTests.Extensions +{ + public class UrlConfigExtensionsTest + { + [Fact] + public void TestSafeUrl() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "name", "this shouldn't show up" }, + }; + UrlDir.UrlConfig url = UrlBuilder.CreateConfig("abc/def", node); + Assert.Equal("abc/def/SOME_NODE", url.SafeUrl()); + } + + [Fact] + public void TestSafeUrl__Null() + { + UrlDir.UrlConfig url = null; + Assert.Equal("", url.SafeUrl()); + } + + [Fact] + public void TestSafeUrl__NullParent() + { + UrlDir.UrlConfig url = new UrlDir.UrlConfig(null, new ConfigNode("SOME_NODE")); + Assert.Equal("SOME_NODE", url.SafeUrl()); + } + + [Fact] + public void TestSafeUrl__NullParent__NullName() + { + ConfigNode node = new ConfigNode + { + name = null + }; + UrlDir.UrlConfig url = new UrlDir.UrlConfig(null, node); + Assert.Equal("", url.SafeUrl()); + } + + [Fact] + public void TestSafeUrl__NullParent__BlankName() + { + UrlDir.UrlConfig url = new UrlDir.UrlConfig(null, new ConfigNode(" ")); + Assert.Equal("", url.SafeUrl()); + } + + [Fact] + public void TestSafeUrl__NullName() + { + ConfigNode node = new TestConfigNode() + { + { "name", "this shouldn't show up" }, + }; + node.name = null; + UrlDir.UrlConfig url = UrlBuilder.CreateConfig("abc/def", node); + Assert.Equal("abc/def/", url.SafeUrl()); + } + + [Fact] + public void TestSafeUrl__BlankName() + { + ConfigNode node = new TestConfigNode(" ") + { + { "name", "this shouldn't show up" }, + }; + UrlDir.UrlConfig url = UrlBuilder.CreateConfig("abc/def", node); + Assert.Equal("abc/def/", url.SafeUrl()); + } + + [Fact] + public void TestPrettyPrint() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE_1") + { + { "mno", "pqr" }, + }, + }; + + UrlDir.UrlConfig url = UrlBuilder.CreateConfig("abc/def.cfg", node); + + string expected = @" +abc/def/SOME_NODE + SOME_NODE + { + abc = def + ghi = jkl + INNER_NODE_1 + { + mno = pqr + } + } +".TrimStart().Replace("\r", null); + + Assert.Equal(expected, url.PrettyPrint()); + } + + [Fact] + public void TestPrettyPrint__NullName() + { + ConfigNode node = new TestConfigNode() + { + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE_1") + { + { "mno", "pqr" }, + }, + }; + + node.name = null; + + UrlDir.UrlConfig url = UrlBuilder.CreateConfig("abc/def.cfg", node); + + string expected = @" +abc/def/ + + { + abc = def + ghi = jkl + INNER_NODE_1 + { + mno = pqr + } + } +".TrimStart().Replace("\r", null); + + Assert.Equal(expected, url.PrettyPrint()); + } + + [Fact] + public void TestPrettyPrint__BlankName() + { + ConfigNode node = new TestConfigNode(" ") + { + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE_1") + { + { "mno", "pqr" }, + }, + }; + + UrlDir.UrlConfig url = UrlBuilder.CreateConfig("abc/def.cfg", node); + + string expected = @" +abc/def/ + + { + abc = def + ghi = jkl + INNER_NODE_1 + { + mno = pqr + } + } +".TrimStart().Replace("\r", null); + + Assert.Equal(expected, url.PrettyPrint()); + } + + [Fact] + public void TestPrettyPrint__NullNameValue() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "name", "temp" }, + { "abc", "def" }, + { "ghi", "jkl" }, + new TestConfigNode("INNER_NODE_1") + { + { "mno", "pqr" }, + }, + }; + + node.values[0].value = null; + + UrlDir.UrlConfig url = UrlBuilder.CreateConfig("abc/def.cfg", node); + + string expected = @" +abc/def/SOME_NODE + SOME_NODE + { + name = + abc = def + ghi = jkl + INNER_NODE_1 + { + mno = pqr + } + } +".TrimStart().Replace("\r", null); + + Assert.Equal(expected, url.PrettyPrint()); + } + + [Fact] + public void TestPrettyPrint__NullNode() + { + UrlDir.UrlConfig url = UrlBuilder.CreateConfig("abc/def.cfg", new ConfigNode("SOME_NODE")); + url.config = null; + + string expected = @" +abc/def/SOME_NODE + +".TrimStart().Replace("\r", null); + + Assert.Equal(expected, url.PrettyPrint()); + } + + [Fact] + public void TestPrettyPrint__Null() + { + UrlDir.UrlConfig url = null; + Assert.Equal("", url.PrettyPrint()); + } + } +} diff --git a/ModuleManagerTests/Extensions/UrlDirExtensionsTest.cs b/ModuleManagerTests/Extensions/UrlDirExtensionsTest.cs new file mode 100644 index 00000000..d7ff2316 --- /dev/null +++ b/ModuleManagerTests/Extensions/UrlDirExtensionsTest.cs @@ -0,0 +1,88 @@ +using System; +using Xunit; +using TestUtils; +using ModuleManager.Extensions; + +namespace ModuleManagerTests.Extensions +{ + public class UrlDirExtensionsTest + { + + [Fact] + public void TestFind__IndirectChild() + { + UrlDir urlDir = UrlBuilder.CreateDir("abc"); + UrlDir.UrlFile urlFile = UrlBuilder.CreateFile("def/ghi.cfg", urlDir); + + Assert.Equal(urlFile, urlDir.Find("def/ghi")); + } + + [Fact] + public void TestFind__DirectChild() + { + UrlDir urlDir = UrlBuilder.CreateDir("abc"); + UrlDir.UrlFile urlFile = UrlBuilder.CreateFile("def.cfg", urlDir); + + Assert.Equal(urlFile, urlDir.Find("def")); + } + + [Fact] + public void TestFind__Extension() + { + UrlDir urlDir = UrlBuilder.CreateDir("abc"); + UrlBuilder.CreateFile("def/ghi.yyy", urlDir); + UrlDir.UrlFile urlFile = UrlBuilder.CreateFile("def/ghi.cfg", urlDir); + UrlBuilder.CreateFile("def/ghi.zzz", urlDir); + + Assert.Equal(urlFile, urlDir.Find("def/ghi.cfg")); + } + + [Fact] + public void TestFind__NotFound() + { + UrlDir urlDir = UrlBuilder.CreateDir("abc"); + UrlBuilder.CreateDir("def", urlDir); + + Assert.Null(urlDir.Find("def/ghi")); + } + + [Fact] + public void TestFind__Extension__NotFound() + { + UrlDir urlDir = UrlBuilder.CreateDir("abc"); + UrlBuilder.CreateFile("def/ghi.yyy", urlDir); + UrlBuilder.CreateFile("def/ghi.zzz", urlDir); + + Assert.Null(urlDir.Find("def/ghi.cfg")); + } + + [Fact] + public void TestFind__IntermediateDirectoryNotFound() + { + UrlDir urlDir = UrlBuilder.CreateDir("abc"); + Assert.Null(urlDir.Find("def/ghi")); + } + + [Fact] + public void TestFind__UrlDirNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + UrlDirExtensions.Find(null, "abc"); + }); + + Assert.Equal("urlDir", ex.ParamName); + } + + [Fact] + public void TestFind__UrlNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + UrlDirExtensions.Find(UrlBuilder.CreateDir("abc"), null); + }); + + Assert.Equal("url", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/Extensions/UrlFileExtensionsTest.cs b/ModuleManagerTests/Extensions/UrlFileExtensionsTest.cs new file mode 100644 index 00000000..147e603e --- /dev/null +++ b/ModuleManagerTests/Extensions/UrlFileExtensionsTest.cs @@ -0,0 +1,17 @@ +using System; +using Xunit; +using TestUtils; +using ModuleManager.Extensions; + +namespace ModuleManagerTests.Extensions +{ + public static class UrlFileExtensionsTest + { + [Fact] + public static void TestGetUrlWithExtension() + { + UrlDir.UrlFile urlFile = UrlBuilder.CreateFile("abc/def/ghi.cfg"); + Assert.Equal("abc/def/ghi.cfg", urlFile.GetUrlWithExtension()); + } + } +} diff --git a/ModuleManagerTests/InGameTestRunnerTest.cs b/ModuleManagerTests/InGameTestRunnerTest.cs new file mode 100644 index 00000000..a75897f4 --- /dev/null +++ b/ModuleManagerTests/InGameTestRunnerTest.cs @@ -0,0 +1,188 @@ +using System; +using System.Linq; +using Xunit; +using NSubstitute; +using UnityEngine; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; + +namespace ModuleManagerTests +{ + public class InGameTestRunnerTest + { + private readonly IBasicLogger logger; + private readonly UrlDir databaseRoot; + private readonly InGameTestRunner testRunner; + + public InGameTestRunnerTest() + { + logger = Substitute.For(); + databaseRoot = UrlBuilder.CreateRoot(); + testRunner = new InGameTestRunner(logger); + } + + [Fact] + public void TestConstructor__LoggerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new InGameTestRunner(null); + }); + + Assert.Equal("logger", ex.ParamName); + } + + [Fact] + public void TestRunTestCases__DatabaseRootNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + testRunner.RunTestCases(null); + }); + + Assert.Equal("gameDatabaseRoot", ex.ParamName); + } + + [Fact] + public void TestRunTestCases__WrongNumberOfNodes() + { + UrlDir.UrlFile file1 = UrlBuilder.CreateFile("abc/blah1.cfg", databaseRoot); + + // Call CreateCopy otherwise XUnit sees that it's an IEnumerable and attempts to compare by enumeration + ConfigNode testNode1 = new TestConfigNode("NODE1") + { + { "key1", "value1" }, + }.CreateCopy(); + + ConfigNode testNode2 = new ConfigNode("NODE2"); + + ConfigNode expectNode = new TestConfigNode("MMTEST_EXPECT") + { + new TestConfigNode("NODE1") + { + { "key1", "value1" }, + }, + }.CreateCopy(); + + UrlBuilder.CreateConfig(testNode1, file1); + UrlBuilder.CreateConfig(testNode2, file1); + UrlBuilder.CreateConfig(expectNode, file1); + + testRunner.RunTestCases(databaseRoot); + + Received.InOrder(delegate + { + logger.AssertInfo("Running tests..."); + logger.AssertError($"Test blah1 failed as expected number of nodes differs expected: 1 found: 2"); + logger.AssertInfo(testNode1.ToString()); + logger.AssertInfo(testNode2.ToString()); + logger.AssertInfo(expectNode.ToString()); + logger.AssertInfo("tests complete."); + }); + + Assert.Equal(3, file1.configs.Count); + Assert.Equal(testNode1, file1.configs[0].config); + Assert.Equal(testNode2, file1.configs[1].config); + Assert.Equal(expectNode, file1.configs[2].config); + } + + [Fact] + public void TestRunTestCases__AllPassing() + { + UrlDir.UrlFile file1 = UrlBuilder.CreateFile("abc/blah1.cfg", databaseRoot); + UrlDir.UrlFile file2 = UrlBuilder.CreateFile("abc/blah2.cfg", databaseRoot); + + ConfigNode testNode1 = new TestConfigNode("NODE1") + { + { "key1", "value1" }, + { "key2", "value2" }, + new TestConfigNode("NODE2") + { + { "key3", "value3" }, + }, + }; + + ConfigNode testNode2 = new TestConfigNode("NODE3") + { + { "key4", "value4" }, + }; + + ConfigNode testNode3 = new TestConfigNode("NODE4") + { + { "key5", "value5" }, + }; + + UrlBuilder.CreateConfig(testNode1, file1); + UrlBuilder.CreateConfig(testNode2, file1); + UrlBuilder.CreateConfig(new TestConfigNode("MMTEST_EXPECT") + { + testNode1.CreateCopy(), + testNode2.CreateCopy(), + }, file1); + + UrlBuilder.CreateConfig(testNode3, file2); + UrlBuilder.CreateConfig(new TestConfigNode("MMTEST_EXPECT") + { + testNode3.CreateCopy(), + }, file2); + + testRunner.RunTestCases(databaseRoot); + + Received.InOrder(delegate + { + logger.AssertInfo("Running tests..."); + logger.AssertInfo("tests complete."); + }); + + logger.AssertNoError(); + + Assert.Empty(file1.configs); + Assert.Empty(file2.configs); + } + + [Fact] + public void TestRunTestCases__Failure() + { + UrlDir.UrlFile file1 = UrlBuilder.CreateFile("abc/blah1.cfg", databaseRoot); + + ConfigNode testNode1 = new TestConfigNode("NODE1") + { + { "key1", "value1" }, + { "key2", "value2" }, + new TestConfigNode("NODE2") + { + { "key3", "value3" }, + }, + }; + + ConfigNode expectNode1 = new TestConfigNode("NODE1") + { + { "key1", "value1" }, + { "key2", "value2" }, + new TestConfigNode("NODE2") + { + { "key4", "value3" }, + }, + }; + + UrlBuilder.CreateConfig(testNode1, file1); + UrlBuilder.CreateConfig(new TestConfigNode("MMTEST_EXPECT") + { + expectNode1, + }, file1); + + testRunner.RunTestCases(databaseRoot); + + Received.InOrder(delegate + { + logger.AssertInfo("Running tests..."); + logger.AssertError($"Test blah1[0] failed as expected output and actual output differ.\nexpected:\n{expectNode1}\nActually got:\n{testNode1}"); + logger.AssertInfo("tests complete."); + }); + + + Assert.Empty(file1.configs); + } + } +} diff --git a/ModuleManagerTests/Logging/LogMessageTest.cs b/ModuleManagerTests/Logging/LogMessageTest.cs new file mode 100644 index 00000000..d70fe8db --- /dev/null +++ b/ModuleManagerTests/Logging/LogMessageTest.cs @@ -0,0 +1,126 @@ +using System; +using Xunit; +using NSubstitute; +using UnityEngine; +using ModuleManager.Logging; + +namespace ModuleManagerTests.Logging +{ + public class LogMessageTest + { + [Fact] + public void TestConstructor() + { + LogMessage logMessage = new LogMessage(LogType.Log, "a message"); + Assert.Equal(LogType.Log, logMessage.LogType); + Assert.True(logMessage.Timestamp <= DateTime.Now); + Assert.True(logMessage.Timestamp > DateTime.Now - new TimeSpan(0, 0, 5)); + Assert.Equal("a message", logMessage.Message); + } + + [Fact] + public void TestConstructor__NullMessage() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new LogMessage(LogType.Log, null); + }); + + Assert.Equal("message", ex.ParamName); + } + + [Fact] + public void TestConstructor__FromOtherMessage() + { + ILogMessage logMessage = Substitute.For(); + logMessage.LogType.Returns(LogType.Log); + logMessage.Message.Returns("the old message"); + logMessage.Timestamp.Returns(new DateTime(2000, 1, 1, 12, 34, 45, 678)); + LogMessage newLogMessage = new LogMessage(logMessage, "a new message"); + Assert.Equal(LogType.Log, newLogMessage.LogType); + Assert.Equal(logMessage.Timestamp, newLogMessage.Timestamp); + Assert.Equal("a new message", newLogMessage.Message); + } + + [Fact] + public void TestConstructor__FromOtherMessage__LogMessageNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new LogMessage(null, "a new message"); + }); + + Assert.Equal("logMessage", ex.ParamName); + } + + [Fact] + public void TestConstructor__FromOtherMessage__NewMessageNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new LogMessage(Substitute.For(), null); + }); + + Assert.Equal("newMessage", ex.ParamName); + } + + [Fact] + public void TestToLogMessage__Info() + { + LogMessage message = new LogMessage(LogType.Log, "everything is ok"); + Assert.Matches(@"^\[LOG \d\d:\d\d:\d\d.\d\d\d\] everything is ok$", message.ToLogString()); + } + + [Fact] + public void TestToLogMessage__Warning() + { + LogMessage message = new LogMessage(LogType.Warning, "I'm warning you"); + Assert.Matches(@"^\[WRN \d\d:\d\d:\d\d.\d\d\d\] I'm warning you$", message.ToLogString()); + } + + [Fact] + public void TestToLogMessage__Error() + { + LogMessage message = new LogMessage(LogType.Error, "You went too far"); + Assert.Matches(@"^\[ERR \d\d:\d\d:\d\d.\d\d\d\] You went too far$", message.ToLogString()); + } + + [Fact] + public void TestToLogMessage__Exception() + { + LogMessage message = new LogMessage(LogType.Exception, "You went too far"); + Assert.Matches(@"^\[EXC \d\d:\d\d:\d\d.\d\d\d\] You went too far$", message.ToLogString()); + } + + [Fact] + public void TestToLogMessage__Assert() + { + LogMessage message = new LogMessage(LogType.Assert, "You went too far"); + Assert.Matches(@"^\[AST \d\d:\d\d:\d\d.\d\d\d\] You went too far$", message.ToLogString()); + } + + [Fact] + public void TestToLogMessage__Unknown() + { + LogMessage message = new LogMessage((LogType)9999, "You went too far"); + Assert.Matches(@"^\[\?\?\? \d\d:\d\d:\d\d.\d\d\d\] You went too far$", message.ToLogString()); + } + + [Fact] + public void TestToString() + { + LogMessage message = new LogMessage(LogType.Log, "everything is ok"); + Assert.Equal("[ModuleManager.Logging.LogMessage LogType=Log Message=everything is ok]", message.ToString()); + } + + [Fact] + public void TestToLogMessage__Timestamp() + { + ILogMessage logMessage = Substitute.For(); + logMessage.LogType.Returns(LogType.Log); + logMessage.Timestamp.Returns(new DateTime(2000, 1, 1, 12, 34, 56, 789)); + LogMessage message = new LogMessage(logMessage, "everything is ok"); + Assert.Equal("[LOG 12:34:56.789] everything is ok", message.ToLogString()); + } + } +} diff --git a/ModuleManagerTests/Logging/LogSplitterTest.cs b/ModuleManagerTests/Logging/LogSplitterTest.cs new file mode 100644 index 00000000..4135f92d --- /dev/null +++ b/ModuleManagerTests/Logging/LogSplitterTest.cs @@ -0,0 +1,57 @@ +using System; +using Xunit; +using NSubstitute; +using UnityEngine; +using ModuleManager.Logging; + +namespace ModuleManagerTests.Logging +{ + public class LogSplitterTest + { + [Fact] + public void TestConstructor__Logger1Null() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new LogSplitter(null, Substitute.For()); + }); + + Assert.Equal("logger1", ex.ParamName); + } + + [Fact] + public void TestConstructor__Logger2Null() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new LogSplitter(Substitute.For(), null); + }); + + Assert.Equal("logger2", ex.ParamName); + } + + [Fact] + public void TestLog() + { + IBasicLogger logger1 = Substitute.For(); + IBasicLogger logger2 = Substitute.For(); + LogSplitter logSplitter = new LogSplitter(logger1, logger2); + ILogMessage message = Substitute.For(); + logSplitter.Log(message); + logger1.Received().Log(message); + logger2.Received().Log(message); + } + + [Fact] + public void TestLog__MessageNull() + { + LogSplitter logSplitter = new LogSplitter(Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + logSplitter.Log(null); + }); + + Assert.Equal("message", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/Logging/PrefixLoggerTest.cs b/ModuleManagerTests/Logging/PrefixLoggerTest.cs new file mode 100644 index 00000000..5aaf0113 --- /dev/null +++ b/ModuleManagerTests/Logging/PrefixLoggerTest.cs @@ -0,0 +1,80 @@ +using System; +using Xunit; +using NSubstitute; +using UnityEngine; +using ModuleManager.Logging; + +namespace ModuleManagerTests.Logging +{ + public class PrefixLoggerTest + { + private readonly IBasicLogger innerLogger = Substitute.For(); + private readonly PrefixLogger logger; + + public PrefixLoggerTest() + { + logger = new PrefixLogger("MyMod", innerLogger); + } + + [Fact] + public void TestConstructor__PrefixNull() + { + ArgumentNullException e = Assert.Throws(delegate + { + new PrefixLogger(null, innerLogger); + }); + + Assert.Equal("prefix", e.ParamName); + } + + [Fact] + public void TestConstructor__PrefixBlank() + { + ArgumentNullException e = Assert.Throws(delegate + { + new PrefixLogger("", innerLogger); + }); + + Assert.Equal("prefix", e.ParamName); + } + + [Fact] + public void TestConstructor__LoggerNull() + { + ArgumentNullException e = Assert.Throws(delegate + { + new PrefixLogger("blah", null); + }); + + Assert.Equal("logger", e.ParamName); + } + + [Fact] + public void TestLog() + { + ILogMessage logMessage = Substitute.For(); + logMessage.LogType.Returns(LogType.Log); + logMessage.Message.Returns("well hi there"); + logMessage.Timestamp.Returns(new DateTime(2000, 1, 1, 12, 34, 45, 678)); + + logger.Log(logMessage); + + innerLogger.Received().Log(Arg.Is(msg => + msg.LogType == LogType.Log && + msg.Timestamp == logMessage.Timestamp && + msg.Message == "[MyMod] well hi there" + )); + } + + [Fact] + public void TestLog__Null() + { + ArgumentNullException ex = Assert.Throws(delegate + { + logger.Log(null); + }); + + Assert.Equal("message", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/Logging/QueueLogRunnerTest.cs b/ModuleManagerTests/Logging/QueueLogRunnerTest.cs new file mode 100644 index 00000000..6a975bd2 --- /dev/null +++ b/ModuleManagerTests/Logging/QueueLogRunnerTest.cs @@ -0,0 +1,152 @@ +using System; +using Xunit; +using NSubstitute; + +using ModuleManager.Collections; +using ModuleManager.Logging; + +namespace ModuleManagerTests.Logging +{ + public class QueueLogRunnerTest + { + [Fact] + public void TestConstructor__LogQueueNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new QueueLogRunner(null); + }); + + Assert.Equal("logQueue", ex.ParamName); + } + + [Fact] + public void TestConstructor__TimeToWaitForLogsMsNegative() + { + ArgumentException ex = Assert.Throws(delegate + { + new QueueLogRunner(Substitute.For>(), -1); + }); + + Assert.Contains("must be non-negative", ex.Message); + Assert.Equal("timeToWaitForLogsMs", ex.ParamName); + } + + [Fact] + public void TestRun() + { + ILogMessage message1 = Substitute.For(); + ILogMessage message2 = Substitute.For(); + ILogMessage message3 = Substitute.For(); + ILogMessage message4 = Substitute.For(); + ILogMessage message5 = Substitute.For(); + ILogMessage message6 = Substitute.For(); + IMessageQueue messageQueue = Substitute.For>(); + QueueLogRunner logRunner = new QueueLogRunner(messageQueue, 0); + int counter = 0; + messageQueue.TakeAll().Returns(delegate + { + IMessageQueue messageQueue2 = Substitute.For>(); + if (counter == 0) + { + messageQueue2.GetEnumerator().Returns(new ArrayEnumerator(message1, message2)); + } + else if (counter == 1) + { + logRunner.RequestStop(); // Called from Running state + messageQueue2.GetEnumerator().Returns(new ArrayEnumerator(message3, message4)); + } + else + { + logRunner.RequestStop(); // Called from StopRequested state + messageQueue2.GetEnumerator().Returns(new ArrayEnumerator(message5, message6)); + } + counter++; + return messageQueue2; + }); + + IBasicLogger logger = Substitute.For(); + + logRunner.Run(logger); + + logRunner.RequestStop(); // Called from Stopped state + + Received.InOrder(delegate + { + logger.Log(message1); + logger.Log(message2); + logger.Log(message3); + logger.Log(message4); + logger.Log(message5); + logger.Log(message6); + }); + } + + [Fact] + public void TestRun__AlreadyStarted() + { + IMessageQueue messageQueue = Substitute.For>(); + QueueLogRunner logRunner = new QueueLogRunner(messageQueue, 0); + int counter = 0; + messageQueue.TakeAll().Returns(delegate + { + IMessageQueue messageQueue2 = Substitute.For>(); + if (counter == 0) + { + InvalidOperationException ex = Assert.Throws(delegate + { + logRunner.Run(Substitute.For()); + }); + Assert.Equal("Cannot run from Running state", ex.Message); + logRunner.RequestStop(); + messageQueue2.GetEnumerator().Returns(new ArrayEnumerator()); + } + else + { + InvalidOperationException ex = Assert.Throws(delegate + { + logRunner.Run(Substitute.For()); + }); + Assert.Equal("Cannot run from StopRequested state", ex.Message); + logRunner.RequestStop(); + messageQueue2.GetEnumerator().Returns(new ArrayEnumerator()); + } + counter++; + return messageQueue2; + }); + + IBasicLogger logger = Substitute.For(); + logRunner.Run(logger); + + InvalidOperationException ex2 = Assert.Throws(delegate + { + logRunner.Run(Substitute.For()); + }); + Assert.Equal("Cannot run from Stopped state", ex2.Message); + } + + [Fact] + public void TestRun__LoggerNull() + { + QueueLogRunner logRunner = new QueueLogRunner(Substitute.For>()); + + ArgumentNullException ex = Assert.Throws(delegate + { + logRunner.Run(null); + }); + Assert.Equal("logger", ex.ParamName); + } + + [Fact] + public void TestRequestStop__NotStarted() + { + QueueLogRunner logRunner = new QueueLogRunner(Substitute.For>()); + + InvalidOperationException ex = Assert.Throws(delegate + { + logRunner.RequestStop(); + }); + Assert.Equal("Cannot request stop from Initialized state", ex.Message); + } + } +} diff --git a/ModuleManagerTests/Logging/QueueLoggerTest.cs b/ModuleManagerTests/Logging/QueueLoggerTest.cs new file mode 100644 index 00000000..25e1abbe --- /dev/null +++ b/ModuleManagerTests/Logging/QueueLoggerTest.cs @@ -0,0 +1,50 @@ +using System; +using Xunit; +using NSubstitute; +using ModuleManager.Collections; +using ModuleManager.Logging; + +namespace ModuleManagerTests.Logging +{ + public class QueueLoggerTest + { + private readonly IMessageQueue queue = Substitute.For>(); + private readonly QueueLogger logger; + + public QueueLoggerTest() + { + logger = new QueueLogger(queue); + } + + [Fact] + public void TestConstructor__QueueNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new QueueLogger(null); + }); + + Assert.Equal("queue", ex.ParamName); + } + + [Fact] + public void TestLog() + { + ILogMessage message = Substitute.For(); + logger.Log(message); + queue.Received().Add(message); + } + + [Fact] + public void TestLog__MessageNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + logger.Log(null); + }); + + Assert.Equal("message", ex.ParamName); + } + + } +} diff --git a/ModuleManagerTests/Logging/StreamLoggerTest.cs b/ModuleManagerTests/Logging/StreamLoggerTest.cs new file mode 100644 index 00000000..296eeac2 --- /dev/null +++ b/ModuleManagerTests/Logging/StreamLoggerTest.cs @@ -0,0 +1,89 @@ +using System; +using System.IO; +using Xunit; +using NSubstitute; +using ModuleManager.Logging; + +namespace ModuleManagerTests.Logging +{ + public class StreamLoggerTest + { + [Fact] + public void TestConstructor__StreamNull() + { + Assert.Throws(delegate + { + new StreamLogger(null); + }); + } + + [Fact] + public void TestConstructor__CantWrite() + { + using (MemoryStream stream = new MemoryStream(new byte[0], false)) + { + Assert.Throws(delegate + { + new StreamLogger(stream); + }); + } + } + + [Fact] + public void TestLog__AlreadyDisposed() + { + using (MemoryStream stream = new MemoryStream(new byte[0], true)) + { + StreamLogger streamLogger = new StreamLogger(stream); + streamLogger.Dispose(); + + InvalidOperationException ex = Assert.Throws(delegate + { + streamLogger.Log(Substitute.For()); + }); + + Assert.Contains("Object has already been disposed", ex.Message); + } + } + + [Fact] + public void TestLog() + { + ILogMessage message = Substitute.For(); + message.ToLogString().Returns("[OMG wtf] bbq"); + byte[] bytes = new byte[15]; + using (MemoryStream stream = new MemoryStream(bytes, true)) + { + using (StreamLogger streamLogger = new StreamLogger(stream)) + { + streamLogger.Log(message); + } + } + + using (MemoryStream stream = new MemoryStream(bytes, false)) + { + using (StreamReader reader = new StreamReader(stream)) + { + string result = reader.ReadToEnd().Trim('\r', '\n', '\0'); + Assert.Equal("[OMG wtf] bbq", result); + } + } + } + + [Fact] + public void TestLog__MessageNull() + { + using (MemoryStream stream = new MemoryStream(new byte[0], true)) + { + StreamLogger streamLogger = new StreamLogger(stream); + + ArgumentNullException ex = Assert.Throws(delegate + { + streamLogger.Log(null); + }); + + Assert.Equal("message", ex.ParamName); + } + } + } +} diff --git a/ModuleManagerTests/Logging/UnityLoggerTest.cs b/ModuleManagerTests/Logging/UnityLoggerTest.cs new file mode 100644 index 00000000..7c4dc4a1 --- /dev/null +++ b/ModuleManagerTests/Logging/UnityLoggerTest.cs @@ -0,0 +1,58 @@ +using System; +using Xunit; +using NSubstitute; +using UnityEngine; +using ModuleManager.Extensions; +using ModuleManager.Logging; + +namespace ModuleManagerTests.Logging +{ + public class UnityLoggerTest + { + private readonly ILogger innerLogger = Substitute.For(); + private readonly UnityLogger logger; + + public UnityLoggerTest() + { + logger = new UnityLogger(innerLogger); + } + + [Fact] + public void TestConstructor__LoggerNull() + { + ArgumentNullException e = Assert.Throws(delegate + { + new UnityLogger(null); + }); + + Assert.Equal("logger", e.ParamName); + } + + [Fact] + public void TestLog__Info() + { + logger.Info("well hi there"); + + innerLogger.Received().Log(LogType.Log, "well hi there"); + } + + [Fact] + public void TestLog__Warning() + { + logger.Warning("I'm warning you"); + + innerLogger.Received().Log(LogType.Warning, "I'm warning you"); + } + + [Fact] + public void TestLog__MessageNull() + { + ArgumentNullException e = Assert.Throws(delegate + { + logger.Log(null); + }); + + Assert.Equal("message", e.ParamName); + } + } +} diff --git a/ModuleManagerTests/LoggingAssertionHelpers.cs b/ModuleManagerTests/LoggingAssertionHelpers.cs new file mode 100644 index 00000000..74ae5cc4 --- /dev/null +++ b/ModuleManagerTests/LoggingAssertionHelpers.cs @@ -0,0 +1,70 @@ +using System; +using UnityEngine; +using NSubstitute; +using ModuleManager.Logging; + +namespace ModuleManagerTests +{ + public static class LoggingAssertionHelpers + { + public static void AssertInfo(this IBasicLogger logger, string message) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.Received().Log(Arg.Is(msg => msg.LogType == LogType.Log && msg.Message == message)); + } + + public static void AssertNoInfo(this IBasicLogger logger) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.DidNotReceive().Log(Arg.Is(msg => msg.LogType == LogType.Log)); + } + + public static void AssertWarning(this IBasicLogger logger, string message) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.Received().Log(Arg.Is(msg => msg.LogType == LogType.Warning && msg.Message == message)); + } + + public static void AssertNoWarning(this IBasicLogger logger) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.DidNotReceive().Log(Arg.Is(msg => msg.LogType == LogType.Warning)); + } + + public static void AssertError(this IBasicLogger logger, string message) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.Received().Log(Arg.Is(msg => msg.LogType == LogType.Error && msg.Message == message)); + } + + public static void AssertNoError(this IBasicLogger logger) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.DidNotReceive().Log(Arg.Is(msg => msg.LogType == LogType.Error)); + } + + public static void AssertException(this IBasicLogger logger, string message, Exception exception) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.Received().Log(Arg.Is(msg => msg.LogType == LogType.Exception && msg.Message == message + ": " + exception.ToString())); + } + + public static void AssertException(this IBasicLogger logger, Exception exception) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.Received().Log(Arg.Is(msg => msg.LogType == LogType.Exception && msg.Message == exception.ToString())); + } + + public static void AssertNoException(this IBasicLogger logger) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.DidNotReceive().Log(Arg.Is(msg => msg.LogType == LogType.Exception)); + } + + public static void AssertNoLog(this IBasicLogger logger) + { + if (logger == null) throw new ArgumentNullException(nameof(logger)); + logger.DidNotReceiveWithAnyArgs().Log(null); + } + } +} diff --git a/ModuleManagerTests/MMPatchLoaderTest.cs b/ModuleManagerTests/MMPatchLoaderTest.cs new file mode 100644 index 00000000..b0617fe8 --- /dev/null +++ b/ModuleManagerTests/MMPatchLoaderTest.cs @@ -0,0 +1,168 @@ +using System; +using System.Linq; +using Xunit; +using NSubstitute; +using UnityEngine; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Progress; +using NodeStack = ModuleManager.Collections.ImmutableStack; + +namespace ModuleManagerTests +{ + // This is not intended to fully test ModifyNode, however it is useful to include tests for bugfixes here before it is split up + public class MMPatchLoaderTest + { + private readonly IBasicLogger logger = Substitute.For(); + private readonly IPatchProgress progress = Substitute.For(); + + [Fact] + public void TestModifyNode__IndexAllWithAssign() + { + ConfigNode c1 = new TestConfigNode("NODE") + { + { "foo", "bar1" }, + { "foo", "bar2" }, + }; + + UrlDir.UrlConfig c2u = UrlBuilder.CreateConfig("abc/def", new TestConfigNode("@NODE") + { + { "@foo,*", "bar3" }, + }); + + PatchContext context = new PatchContext(c2u, Enumerable.Empty(), logger, progress); + + ConfigNode c3 = MMPatchLoader.ModifyNode(new NodeStack(c1), c2u.config, context); + + EnsureNoErrors(); + + AssertConfigNodesEqual(new TestConfigNode("NODE") + { + { "foo", "bar3" }, + { "foo", "bar3" }, + }, c3); + } + + [Fact] + public void TestModifyNode__MultiplyValue() + { + ConfigNode c1 = new TestConfigNode("NODE") + { + { "foo", "3" }, + { "foo", "5" }, + }; + + UrlDir.UrlConfig c2u = UrlBuilder.CreateConfig("abc/def", new TestConfigNode("@NODE") + { + { "@foo *", "2" }, + }); + + PatchContext context = new PatchContext(c2u, Enumerable.Empty(), logger, progress); + + ConfigNode c3 = MMPatchLoader.ModifyNode(new NodeStack(c1), c2u.config, context); + + EnsureNoErrors(); + + AssertConfigNodesEqual(new TestConfigNode("NODE") + { + { "foo", "6" }, + { "foo", "5" }, + }, c3); + } + + [Fact] + public void TestModifyNode__EditNode__SpecialCharacters() + { + ConfigNode c1 = new TestConfigNode("NODE") + { + new TestConfigNode("INNER_NODE") + { + { "weird_values", "some\r\n\tstuff" }, + }, + }; + + UrlDir.UrlConfig c2u = UrlBuilder.CreateConfig("abc/def", new TestConfigNode("@NODE") + { + new TestConfigNode("@INNER_NODE") + { + { "another_weird_value", "some\r\nmore\tstuff" }, + }, + }); + + PatchContext context = new PatchContext(c2u, Enumerable.Empty(), logger, progress); + + ConfigNode c3 = MMPatchLoader.ModifyNode(new NodeStack(c1), c2u.config, context); + + EnsureNoErrors(); + + AssertConfigNodesEqual(new TestConfigNode("NODE") + { + new TestConfigNode("INNER_NODE") + { + { "weird_values", "some\r\n\tstuff" }, + { "another_weird_value", "some\r\nmore\tstuff" }, + }, + }, c3); + } + + [Fact] + public void TestModifyNode__ReplaceNode__SpecialCharacters() + { + ConfigNode c1 = new TestConfigNode("NODE") + { + new TestConfigNode("INNER_NODE") + { + { "weird_values", "some\r\n\tstuff" }, + }, + }; + + UrlDir.UrlConfig c2u = UrlBuilder.CreateConfig("abc/def", new TestConfigNode("@NODE") + { + new TestConfigNode("%INNER_NODE") + { + { "another_weird_value", "some\r\nmore\tstuff" }, + }, + new TestConfigNode("%OTHER_INNER_NODE") + { + { "another_weirder_value", "even\r\nmore\tstuff" }, + }, + }); + + PatchContext context = new PatchContext(c2u, Enumerable.Empty(), logger, progress); + + ConfigNode c3 = MMPatchLoader.ModifyNode(new NodeStack(c1), c2u.config, context); + + EnsureNoErrors(); + + AssertConfigNodesEqual(new TestConfigNode("NODE") + { + new TestConfigNode("INNER_NODE") + { + { "weird_values", "some\r\n\tstuff" }, + { "another_weird_value", "some\r\nmore\tstuff" }, + }, + new TestConfigNode("OTHER_INNER_NODE") + { + { "another_weirder_value", "even\r\nmore\tstuff" }, + }, + }, c3); + } + + private void AssertConfigNodesEqual(ConfigNode expected, ConfigNode observed) + { + Assert.Equal(expected.ToString(), observed.ToString()); + } + + private void EnsureNoErrors() + { + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + + logger.AssertNoWarning(); + logger.AssertNoError(); + logger.AssertNoException(); + } + } +} diff --git a/ModuleManagerTests/ModuleManagerTests.csproj b/ModuleManagerTests/ModuleManagerTests.csproj new file mode 100644 index 00000000..f3afbbf5 --- /dev/null +++ b/ModuleManagerTests/ModuleManagerTests.csproj @@ -0,0 +1,168 @@ + + + + + + + + Debug + AnyCPU + {BC2A08C8-64EF-4823-A40B-8889C1CCFD75} + Library + Properties + ModuleManagerTests + ModuleManagerTests + v4.7.1 + 512 + + + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + false + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + false + + + 8.0 + + + + + ..\packages\Castle.Core.4.4.1\lib\net45\Castle.Core.dll + + + + ..\packages\NSubstitute.4.2.2\lib\net46\NSubstitute.dll + + + + + + ..\packages\System.Runtime.CompilerServices.Unsafe.5.0.0\lib\net45\System.Runtime.CompilerServices.Unsafe.dll + + + ..\packages\System.Threading.Tasks.Extensions.4.5.4\lib\net461\System.Threading.Tasks.Extensions.dll + + + + + + + + + ..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll + True + + + ..\packages\xunit.assert.2.4.1\lib\netstandard1.1\xunit.assert.dll + + + ..\packages\xunit.extensibility.core.2.4.1\lib\net452\xunit.core.dll + + + ..\packages\xunit.extensibility.execution.2.4.1\lib\net452\xunit.execution.desktop.dll + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {02c8e3af-69f9-4102-ab60-dd6de60662d3} + ModuleManager + + + {20eaafe6-510d-4374-8d2f-6b52d0178e85} + TestUtils + + + + + + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + + + + + \ No newline at end of file diff --git a/ModuleManagerTests/NeedsCheckerTest.cs b/ModuleManagerTests/NeedsCheckerTest.cs new file mode 100644 index 00000000..4d3540b9 --- /dev/null +++ b/ModuleManagerTests/NeedsCheckerTest.cs @@ -0,0 +1,383 @@ +using System; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Progress; + +namespace ModuleManagerTests +{ + public class NeedsCheckerTest + { + private readonly UrlDir gameData; + + private readonly IPatchProgress progress = Substitute.For(); + private readonly IBasicLogger logger = Substitute.For(); + private readonly NeedsChecker needsChecker; + + public NeedsCheckerTest() + { + gameData = UrlBuilder.CreateGameData(); + needsChecker = new NeedsChecker(new[] { "mod1", "mod2", "mod/2" }, gameData, progress, logger); + } + + [Fact] + public void TestConstructor__ModsNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new NeedsChecker(null, gameData, progress, logger); + }); + + Assert.Equal("mods", ex.ParamName); + } + + [Fact] + public void TestConstructor__GameDataNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new NeedsChecker(new string[0], null, progress, logger); + }); + + Assert.Equal("gameData", ex.ParamName); + } + + [Fact] + public void TestConstructor__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new NeedsChecker(new string[0], gameData, null, logger); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestConstructor__LoggerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new NeedsChecker(new string[0], gameData, progress, null); + }); + + Assert.Equal("logger", ex.ParamName); + } + + [Fact] + public void TestCheckNeedsExpression() + { + Assert.True(needsChecker.CheckNeedsExpression("mod1")); + Assert.True(needsChecker.CheckNeedsExpression("mod2")); + Assert.False(needsChecker.CheckNeedsExpression("mod3")); + } + + [Fact] + public void TestCheckNeedsExpression__AndOr() + { + Assert.True(needsChecker.CheckNeedsExpression("mod1&mod2")); + Assert.True(needsChecker.CheckNeedsExpression("mod1,mod2")); + Assert.True(needsChecker.CheckNeedsExpression("mod1|mod2")); + Assert.True(needsChecker.CheckNeedsExpression("mod1|mod3")); + Assert.True(needsChecker.CheckNeedsExpression("mod1&mod2|mod3")); + Assert.True(needsChecker.CheckNeedsExpression("mod1,mod2|mod3")); + Assert.True(needsChecker.CheckNeedsExpression("mod1|mod3&mod2")); + Assert.True(needsChecker.CheckNeedsExpression("mod1|mod3,mod2")); + + Assert.False(needsChecker.CheckNeedsExpression("mod1&mod3")); + Assert.False(needsChecker.CheckNeedsExpression("mod1,mod3")); + Assert.False(needsChecker.CheckNeedsExpression("mod1&mod2&mod3")); + Assert.False(needsChecker.CheckNeedsExpression("mod1,mod2,mod3")); + Assert.False(needsChecker.CheckNeedsExpression("mod3|mod4")); + Assert.False(needsChecker.CheckNeedsExpression("mod1|mod2&mod3")); + Assert.False(needsChecker.CheckNeedsExpression("mod1|mod2,mod3")); + Assert.False(needsChecker.CheckNeedsExpression("mod3&mod1|mod2")); + Assert.False(needsChecker.CheckNeedsExpression("mod3,mod1|mod2")); + } + + [Fact] + public void TestCheckNeedsExpression__Not() + { + Assert.True(needsChecker.CheckNeedsExpression("!mod3")); + Assert.True(needsChecker.CheckNeedsExpression("mod1,!mod3")); + Assert.True(needsChecker.CheckNeedsExpression("!mod1|!mod3")); + Assert.True(needsChecker.CheckNeedsExpression("mod1|!mod2")); + + Assert.False(needsChecker.CheckNeedsExpression("!mod1")); + Assert.False(needsChecker.CheckNeedsExpression("!mod1,mod2")); + Assert.False(needsChecker.CheckNeedsExpression("!mod1&!mod3")); + } + + [Fact] + public void TestCheckNeedsExpression__Capitalization() + { + Assert.True(needsChecker.CheckNeedsExpression("mod1")); + Assert.True(needsChecker.CheckNeedsExpression("Mod1")); + Assert.True(needsChecker.CheckNeedsExpression("MOD1")); + + Assert.False(needsChecker.CheckNeedsExpression("mod3")); + Assert.False(needsChecker.CheckNeedsExpression("Mod3")); + Assert.False(needsChecker.CheckNeedsExpression("MOD3")); + } + + [Fact] + public void TestCheckNeedsExpression__Directory() + { + UrlBuilder.CreateDir("abc", gameData); + UrlBuilder.CreateDir("ghi/jkl", gameData); + + Assert.True(needsChecker.CheckNeedsExpression("/abc")); + Assert.True(needsChecker.CheckNeedsExpression("abc/")); + Assert.True(needsChecker.CheckNeedsExpression("/abc/")); + Assert.True(needsChecker.CheckNeedsExpression("ghi/jkl")); + Assert.True(needsChecker.CheckNeedsExpression("/ghi/jkl")); + Assert.True(needsChecker.CheckNeedsExpression("ghi/jkl/")); + Assert.True(needsChecker.CheckNeedsExpression("mod1&ghi/jkl")); + Assert.True(needsChecker.CheckNeedsExpression("mod3|ghi/jkl")); + Assert.True(needsChecker.CheckNeedsExpression("abc/&ghi/jkl")); + Assert.True(needsChecker.CheckNeedsExpression("mod/2")); + + Assert.False(needsChecker.CheckNeedsExpression("abc")); + Assert.False(needsChecker.CheckNeedsExpression("mod3&ghi/jkl")); + Assert.False(needsChecker.CheckNeedsExpression("Ghi/jkl")); + Assert.False(needsChecker.CheckNeedsExpression("mno/pqr")); + } + + [Fact] + public void TestCheckNeedsExpression__Null() + { + ArgumentNullException ex = Assert.Throws(delegate + { + needsChecker.CheckNeedsExpression(null); + }); + + Assert.Equal("needsExpression", ex.ParamName); + } + + [Fact] + public void TestCheckNeedsExpression__Empty() + { + ArgumentException ex = Assert.Throws(delegate + { + needsChecker.CheckNeedsExpression(""); + }); + + Assert.Equal("needsExpression", ex.ParamName); + Assert.Contains("can't be empty", ex.Message); + } + + [Fact] + public void TestCheckNeeds() + { + UrlBuilder.CreateDir("ghi/jkl", gameData); + + Assert.True(needsChecker.CheckNeeds("mod1")); + Assert.True(needsChecker.CheckNeeds("MOD1")); + Assert.True(needsChecker.CheckNeeds("mod2")); + + Assert.False(needsChecker.CheckNeeds("mod1&mod2")); + Assert.False(needsChecker.CheckNeeds("ghi/jkl")); + } + + [Fact] + public void TestCheckNeeds__Null() + { + ArgumentNullException ex = Assert.Throws(delegate + { + needsChecker.CheckNeeds(null); + }); + + Assert.Equal("mod", ex.ParamName); + } + + [Fact] + public void TestCheckNeeds__Empty() + { + ArgumentException ex = Assert.Throws(delegate + { + needsChecker.CheckNeeds(""); + }); + + Assert.Equal("mod", ex.ParamName); + Assert.Contains("can't be empty", ex.Message); + } + + [Fact] + public void TestCheckNeedsRecursive() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "aa", "00" }, + { "bb:NEEDS[mod1]", "01" }, + { "cc:NEEDS[mod3]", "02" }, + new TestConfigNode("INNER_NODE_1") + { + { "dd", "03" }, + { "ee", "04" }, + new TestConfigNode("INNER_INNER_NODE_1") + { + { "ff", "05" }, + }, + }, + new TestConfigNode("INNER_NODE_2") + { + { "gg:NEEDS[mod1]", "06" }, + { "hh:NEEDS[mod3]", "07" }, + { "ii", "08" }, + new TestConfigNode("INNER_INNER_NODE_11") + { + { "jj", "09" }, + }, + new TestConfigNode("INNER_INNER_NODE_12:NEEDS[mod2]") + { + { "kk", "10" }, + }, + new TestConfigNode("INNER_INNER_NODE_12:NEEDS[mod3]") + { + { "ll", "11" }, + }, + }, + new TestConfigNode("INNER_NODE_3:NEEDS[mod1]") + { + { "mm:NEEDS[mod1]", "12" }, + { "nn:NEEDS[mod3]", "13" }, + { "oo", "14" }, + new TestConfigNode("INNER_INNER_NODE_21") + { + { "pp", "15" }, + }, + new TestConfigNode("INNER_INNER_NODE_22:NEEDS[mod2]") + { + { "qq", "16" }, + }, + new TestConfigNode("INNER_INNER_NODE_22:NEEDS[mod3]") + { + { "rr", "17" }, + }, + }, + new TestConfigNode("INNER_NODE_4:NEEDS[mod3]") + { + { "ss:NEEDS[mod1]", "18" }, + }, + }; + + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", node); + + needsChecker.CheckNeedsRecursive(node, urlConfig); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + + Received.InOrder(delegate + { + progress.NeedsUnsatisfiedValue(urlConfig, "SOME_NODE/cc:NEEDS[mod3]"); + progress.NeedsUnsatisfiedValue(urlConfig, "SOME_NODE/INNER_NODE_2/hh:NEEDS[mod3]"); + progress.NeedsUnsatisfiedNode(urlConfig, "SOME_NODE/INNER_NODE_2/INNER_INNER_NODE_12:NEEDS[mod3]"); + progress.NeedsUnsatisfiedValue(urlConfig, "SOME_NODE/INNER_NODE_3/nn:NEEDS[mod3]"); + progress.NeedsUnsatisfiedNode(urlConfig, "SOME_NODE/INNER_NODE_3/INNER_INNER_NODE_22:NEEDS[mod3]"); + progress.NeedsUnsatisfiedNode(urlConfig, "SOME_NODE/INNER_NODE_4:NEEDS[mod3]"); + }); + + Assert.Equal(2, node.values.Count); + Assert.Equal(3, node.nodes.Count); + + Assert.Equal("aa", node.values[0].name); + Assert.Equal("00", node.values[0].value); + + Assert.Equal("bb", node.values[1].name); + Assert.Equal("01", node.values[1].value); + + Assert.Same(node.nodes[0], node.nodes[0]); + Assert.Equal("INNER_NODE_1", node.nodes[0].name); + + Assert.Equal(2, node.nodes[0].values.Count); + Assert.Equal(1, node.nodes[0].nodes.Count); + + Assert.Equal("dd", node.nodes[0].values[0].name); + Assert.Equal("03", node.nodes[0].values[0].value); + + Assert.Equal("ee", node.nodes[0].values[1].name); + Assert.Equal("04", node.nodes[0].values[1].value); + + Assert.Equal("INNER_INNER_NODE_1", node.nodes[0].nodes[0].name); + + Assert.Equal(1, node.nodes[0].nodes[0].values.Count); + Assert.Equal(0, node.nodes[0].nodes[0].nodes.Count); + + Assert.Equal("ff", node.nodes[0].nodes[0].values[0].name); + Assert.Equal("05", node.nodes[0].nodes[0].values[0].value); + + // Assert.NotSame(node.nodes[1], newNode.nodes[1]); + Assert.Equal("INNER_NODE_2", node.nodes[1].name); + + Assert.Equal(2, node.nodes[1].values.Count); + Assert.Equal(2, node.nodes[1].nodes.Count); + + Assert.Equal("gg", node.nodes[1].values[0].name); + Assert.Equal("06", node.nodes[1].values[0].value); + + Assert.Equal("ii", node.nodes[1].values[1].name); + Assert.Equal("08", node.nodes[1].values[1].value); + + Assert.Equal("INNER_INNER_NODE_11", node.nodes[1].nodes[0].name); + + Assert.Equal("jj", node.nodes[1].nodes[0].values[0].name); + Assert.Equal("09", node.nodes[1].nodes[0].values[0].value); + + Assert.Equal("INNER_INNER_NODE_12", node.nodes[1].nodes[1].name); + + Assert.Equal("kk", node.nodes[1].nodes[1].values[0].name); + Assert.Equal("10", node.nodes[1].nodes[1].values[0].value); + + // Assert.NotSame(node.nodes[1], newNode.nodes[1]); + Assert.Equal("INNER_NODE_3", node.nodes[2].name); + + Assert.Equal(2, node.nodes[2].values.Count); + Assert.Equal(2, node.nodes[2].nodes.Count); + + Assert.Equal("mm", node.nodes[2].values[0].name); + Assert.Equal("12", node.nodes[2].values[0].value); + + Assert.Equal("oo", node.nodes[2].values[1].name); + Assert.Equal("14", node.nodes[2].values[1].value); + + Assert.Equal("INNER_INNER_NODE_21", node.nodes[2].nodes[0].name); + + Assert.Equal("pp", node.nodes[2].nodes[0].values[0].name); + Assert.Equal("15", node.nodes[2].nodes[0].values[0].value); + + Assert.Equal("INNER_INNER_NODE_22", node.nodes[2].nodes[1].name); + + Assert.Equal("qq", node.nodes[2].nodes[1].values[0].name); + Assert.Equal("16", node.nodes[2].nodes[1].values[0].value); + + } + + [Fact] + public void TestCheckNeedsRecursive__NodeNull() + { + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE")); + ArgumentNullException ex = Assert.Throws(delegate + { + needsChecker.CheckNeedsRecursive(null, urlConfig); + }); + + Assert.Equal("node", ex.ParamName); + } + + [Fact] + public void TestCheckNeedsRecursive__UrlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + needsChecker.CheckNeedsRecursive(new ConfigNode(), null); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/NodeMatcherTest.cs b/ModuleManagerTests/NodeMatcherTest.cs new file mode 100644 index 00000000..866c69fc --- /dev/null +++ b/ModuleManagerTests/NodeMatcherTest.cs @@ -0,0 +1,333 @@ +using System; +using Xunit; +using TestUtils; +using ModuleManager; + +namespace ModuleManagerTests +{ + public class NodeMatcherTest + { + #region Constructor + + [Fact] + public void TestConstructor__TypeNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new NodeMatcher(null, null, null); + }); + + Assert.Equal("type", ex.ParamName); + } + + [Fact] + public void TestConstructor__TypeBlank() + { + ArgumentException ex = Assert.Throws(delegate + { + new NodeMatcher("", null, null); + }); + + Assert.Equal("type", ex.ParamName); + Assert.Contains("can't be empty", ex.Message); + } + + [Fact] + public void TestConstructor__NameBlank() + { + ArgumentException ex = Assert.Throws(delegate + { + new NodeMatcher("NODE", "", null); + }); + + Assert.Equal("name", ex.ParamName); + Assert.Contains("can't be empty (null allowed)", ex.Message); + } + + [Fact] + public void TestConstructor__ConstraintsBlank() + { + ArgumentException ex = Assert.Throws(delegate + { + new NodeMatcher("NODE", null, ""); + }); + + Assert.Equal("constraints", ex.ParamName); + Assert.Contains("can't be empty (null allowed)", ex.Message); + } + + [Fact] + public void TestConstructor__ConstraintsNotBracketBalanced() + { + ArgumentException ex = Assert.Throws(delegate + { + new NodeMatcher("NODE", null, "stuff[blah"); + }); + + Assert.Equal("constraints", ex.ParamName); + Assert.Contains("is not bracket balanced: stuff[blah", ex.Message); + } + + #endregion + + #region IsMatch + + [Fact] + public void TestIsMatch() + { + NodeMatcher matcher = new NodeMatcher("NODE", null, null); + + Assert.True(matcher.IsMatch(new ConfigNode("NODE"))); + Assert.False(matcher.IsMatch(new ConfigNode("PART"))); + } + + [Fact] + public void TestIsMatch__Name() + { + NodeMatcher matcher = new NodeMatcher("NODE", "blah", null); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + })); + + Assert.False(matcher.IsMatch(new ConfigNode("NODE"))); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "bleh" }, + })); + + Assert.False(matcher.IsMatch(new ConfigNode("PART"))); + + Assert.False(matcher.IsMatch(new TestConfigNode("PART") + { + { "name", "blah" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("PART") + { + { "name", "bleh" }, + })); + } + + [Fact] + public void TestIsMatch__Name__Wildcard() + { + NodeMatcher matcher = new NodeMatcher("NODE", "bl*h", null); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + })); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blablah" }, + })); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "bleh" }, + })); + + Assert.False(matcher.IsMatch(new ConfigNode("NODE"))); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blue" }, + })); + + Assert.False(matcher.IsMatch(new ConfigNode("PART"))); + + Assert.False(matcher.IsMatch(new TestConfigNode("PART") + { + { "name", "blah" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("PART") + { + { "name", "blue" }, + })); + } + + [Fact] + public void TestIsMatch__Name__Multiple() + { + NodeMatcher matcher = new NodeMatcher("NODE", "blah|bleh|blih*", null); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + })); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "bleh" }, + })); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blih" }, + })); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blihblih" }, + })); + + Assert.False(matcher.IsMatch(new ConfigNode("NODE"))); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "bloh" }, + })); + + Assert.False(matcher.IsMatch(new ConfigNode("PART"))); + + Assert.False(matcher.IsMatch(new TestConfigNode("PART") + { + { "name", "blah" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("PART") + { + { "name", "bleh" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("PART") + { + { "name", "blih" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("PART") + { + { "name", "bloh" }, + })); + } + + [Fact] + public void TestIsMatch__Constraints() + { + NodeMatcher matcher = new NodeMatcher("NODE", "blah", "@FOO[bar*],#something[else]"); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + { "something", "else" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + { "something", "else" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "bleh" }, + { "something", "else" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NADE") + { + { "name", "blah" }, + { "something", "else" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + } + + [Fact] + public void TestIsMatch__Constraints_Open() + { + NodeMatcher matcher = new NodeMatcher("NODE", "blah", "@FOO,#something"); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + { "something", "else" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + { "something", "else" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + { "something", "else" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "blah" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "bleh" }, + { "something", "else" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NADE") + { + { "name", "blah" }, + { "something", "else" }, + new TestConfigNode("FOO") + { + { "name", "barbar" }, + }, + })); + } + + #endregion + } +} diff --git a/ModuleManagerTests/OperatorParserTest.cs b/ModuleManagerTests/OperatorParserTest.cs new file mode 100644 index 00000000..dfc35d2a --- /dev/null +++ b/ModuleManagerTests/OperatorParserTest.cs @@ -0,0 +1,110 @@ +using System; +using Xunit; +using ModuleManager; + +namespace ModuleManagerTests +{ + public class OperatorParserTest + { + [Fact] + public void TestParse__Null() + { + ArgumentNullException ex = Assert.Throws(delegate + { + OperatorParser.Parse(null, out string _); + }); + + Assert.Equal("name", ex.ParamName); + } + + [Fact] + public void TestParse__Empty() + { + Operator op = OperatorParser.Parse("", out string result); + + Assert.Equal(Operator.Assign, op); + Assert.Equal("", result); + } + + [Fact] + public void TestParse__Assign() + { + Operator op = OperatorParser.Parse("some_stuff,1[2, ]", out string result); + + Assert.Equal(Operator.Assign, op); + Assert.Equal("some_stuff,1[2, ]", result); + } + + [Fact] + public void TestParse__Add() + { + Operator op = OperatorParser.Parse("some_stuff,1[2, ] +", out string result); + + Assert.Equal(Operator.Add, op); + Assert.Equal("some_stuff,1[2, ]", result); + } + + [Fact] + public void TestParse__Subtract() + { + Operator op = OperatorParser.Parse("some_stuff,1[2, ] -", out string result); + + Assert.Equal(Operator.Subtract, op); + Assert.Equal("some_stuff,1[2, ]", result); + } + + [Fact] + public void TestParse__Multiply() + { + Operator op = OperatorParser.Parse("some_stuff,1[2, ] *", out string result); + + Assert.Equal(Operator.Multiply, op); + Assert.Equal("some_stuff,1[2, ]", result); + } + + [Fact] + public void TestParse__Divide() + { + Operator op = OperatorParser.Parse("some_stuff,1[2, ] /", out string result); + + Assert.Equal(Operator.Divide, op); + Assert.Equal("some_stuff,1[2, ]", result); + } + + [Fact] + public void TestParse__Exponentiate() + { + Operator op = OperatorParser.Parse("some_stuff,1[2, ] !", out string result); + + Assert.Equal(Operator.Exponentiate, op); + Assert.Equal("some_stuff,1[2, ]", result); + } + + [Fact] + public void TestParse__RegexReplace() + { + Operator op = OperatorParser.Parse("some_stuff,1[2, ] ^", out string result); + + Assert.Equal(Operator.RegexReplace, op); + Assert.Equal("some_stuff,1[2, ]", result); + } + + [Fact] + public void TestParse__NoSpaceMeansNoOp() + { + Operator op = OperatorParser.Parse("some_stuff*", out string result); + + Assert.Equal(Operator.Assign, op); + Assert.Equal("some_stuff*", result); + } + + [Fact] + public void TestParse__SingleCharacterNotOp() + { + Operator op = OperatorParser.Parse("*", out string result); + + Assert.Equal(Operator.Assign, op); + Assert.Equal("*", result); + } + } +} diff --git a/ModuleManagerTests/PassTest.cs b/ModuleManagerTests/PassTest.cs new file mode 100644 index 00000000..bc829816 --- /dev/null +++ b/ModuleManagerTests/PassTest.cs @@ -0,0 +1,69 @@ +using System; +using System.Linq; +using Xunit; +using NSubstitute; +using ModuleManager; +using ModuleManager.Patches; + +namespace ModuleManagerTests +{ + public class PassTest + { + [Fact] + public void TestConstructor__NameNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new Pass(null); + }); + + Assert.Equal("name", ex.ParamName); + } + + [Fact] + public void TestConstructor__NameEmpty() + { + ArgumentException ex = Assert.Throws(delegate + { + new Pass(""); + }); + + Assert.Contains("can't be empty", ex.Message); + Assert.Equal("name", ex.ParamName); + } + + [Fact] + public void TestName() + { + Pass pass = new Pass(":NOTINAMILLIONYEARS"); + + Assert.Equal(":NOTINAMILLIONYEARS", pass.Name); + } + + [Fact] + public void Test__Add__Enumerator() + { + IPatch[] patches = + { + Substitute.For(), + Substitute.For(), + Substitute.For(), + }; + + Pass pass = new Pass("blah") + { + patches[0], + patches[1], + patches[2], + }; + + IPatch[] passPatches = pass.ToArray(); + Assert.Equal(patches.Length, passPatches.Length); + + for (int i = 0; i < patches.Length; i++) + { + Assert.Same(patches[i], passPatches[i]); + } + } + } +} diff --git a/ModuleManagerTests/PatchApplierTest.cs b/ModuleManagerTests/PatchApplierTest.cs new file mode 100644 index 00000000..d54ac286 --- /dev/null +++ b/ModuleManagerTests/PatchApplierTest.cs @@ -0,0 +1,119 @@ +using System; +using System.Collections.Generic; +using Xunit; +using NSubstitute; +using UnityEngine; +using ModuleManager; +using ModuleManager.Collections; +using ModuleManager.Logging; +using ModuleManager.Patches; +using ModuleManager.Progress; + +namespace ModuleManagerTests +{ + public class PatchApplierTest + { + [Fact] + public void TestConstructor__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchApplier(null, Substitute.For()); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestConstructor__LoggerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchApplier(Substitute.For(), null); + }); + + Assert.Equal("logger", ex.ParamName); + } + + [Fact] + public void TestApplyPatches__PatchesNull() + { + PatchApplier applier = new PatchApplier(Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + applier.ApplyPatches(null); + }); + + Assert.Equal("patches", ex.ParamName); + } + + [Fact] + public void TestApplyPatches() + { + IBasicLogger logger = Substitute.For(); + IPatchProgress progress = Substitute.For(); + PatchApplier patchApplier = new PatchApplier(progress, logger); + IPass pass1 = Substitute.For(); + IPass pass2 = Substitute.For(); + IPass pass3 = Substitute.For(); + pass1.Name.Returns(":PASS1"); + pass2.Name.Returns(":PASS2"); + pass3.Name.Returns(":PASS3"); + + UrlDir.UrlConfig[] patchUrlConfigs = new UrlDir.UrlConfig[9]; + IPatch[] patches = new IPatch[9]; + for (int i = 0; i < patches.Length; i++) + { + patches[i] = Substitute.For(); + } + + patches[0].CountsAsPatch.Returns(false); + patches[1].CountsAsPatch.Returns(false); + patches[2].CountsAsPatch.Returns(false); + patches[3].CountsAsPatch.Returns(true); + patches[4].CountsAsPatch.Returns(true); + patches[5].CountsAsPatch.Returns(true); + patches[6].CountsAsPatch.Returns(true); + patches[7].CountsAsPatch.Returns(true); + patches[8].CountsAsPatch.Returns(true); + + pass1.GetEnumerator().Returns(new ArrayEnumerator(patches[0], patches[1], patches[2])); + pass2.GetEnumerator().Returns(new ArrayEnumerator(patches[3], patches[4], patches[5])); + pass3.GetEnumerator().Returns(new ArrayEnumerator(patches[6], patches[7], patches[8])); + + IPass[] patchList = new IPass[] { pass1, pass2, pass3 }; + + LinkedList databaseConfigs = Assert.IsType>(patchApplier.ApplyPatches(new[] { pass1, pass2, pass3 })); + + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + + logger.AssertNoWarning(); + logger.AssertNoError(); + logger.AssertNoException(); + + Received.InOrder(delegate + { + progress.PassStarted(pass1); + patches[0].Apply(databaseConfigs, progress, logger); + patches[1].Apply(databaseConfigs, progress, logger); + patches[2].Apply(databaseConfigs, progress, logger); + progress.PassStarted(pass2); + patches[3].Apply(databaseConfigs, progress, logger); + progress.PatchApplied(); + patches[4].Apply(databaseConfigs, progress, logger); + progress.PatchApplied(); + patches[5].Apply(databaseConfigs, progress, logger); + progress.PatchApplied(); + progress.PassStarted(pass3); + patches[6].Apply(databaseConfigs, progress, logger); + progress.PatchApplied(); + patches[7].Apply(databaseConfigs, progress, logger); + progress.PatchApplied(); + patches[8].Apply(databaseConfigs, progress, logger); + progress.PatchApplied(); + }); + } + } +} diff --git a/ModuleManagerTests/PatchExtractorTest.cs b/ModuleManagerTests/PatchExtractorTest.cs new file mode 100644 index 00000000..49a12583 --- /dev/null +++ b/ModuleManagerTests/PatchExtractorTest.cs @@ -0,0 +1,389 @@ +using System; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; +using ModuleManager.Tags; + +namespace ModuleManagerTests +{ + public class PatchExtractorTest + { + private readonly UrlDir root; + private readonly UrlDir.UrlFile file; + + private readonly IPatchProgress progress; + private readonly IBasicLogger logger; + private readonly INeedsChecker needsChecker; + private readonly ITagListParser tagListParser; + private readonly IProtoPatchBuilder protoPatchBuilder; + private readonly IPatchCompiler patchCompiler; + private readonly PatchExtractor patchExtractor; + + public PatchExtractorTest() + { + root = UrlBuilder.CreateRoot(); + file = UrlBuilder.CreateFile("abc/def.cfg", root); + + progress = Substitute.For(); + logger = Substitute.For(); + needsChecker = Substitute.For(); + tagListParser = Substitute.For(); + protoPatchBuilder = Substitute.For(); + patchCompiler = Substitute.For(); + patchExtractor = new PatchExtractor(progress, logger, needsChecker, tagListParser, protoPatchBuilder, patchCompiler); + } + + [Fact] + public void TestConstructor__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchExtractor(null, logger, needsChecker, tagListParser, protoPatchBuilder, patchCompiler); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestConstructor__LoggerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchExtractor(progress, null, needsChecker, tagListParser, protoPatchBuilder, patchCompiler); + }); + + Assert.Equal("logger", ex.ParamName); + } + + [Fact] + public void TestConstructor__NeedsCheckerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchExtractor(progress, logger, null, tagListParser, protoPatchBuilder, patchCompiler); + }); + + Assert.Equal("needsChecker", ex.ParamName); + } + + [Fact] + public void TestConstructor__TagListParserNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchExtractor(progress, logger, needsChecker, null, protoPatchBuilder, patchCompiler); + }); + + Assert.Equal("tagListParser", ex.ParamName); + } + + [Fact] + public void TestConstructor__ProtoPatchBuilderNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchExtractor(progress, logger, needsChecker, tagListParser, null, patchCompiler); + }); + + Assert.Equal("protoPatchBuilder", ex.ParamName); + } + + [Fact] + public void TestConstructor__PatchCompilerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchExtractor(progress, logger, needsChecker, tagListParser, protoPatchBuilder, null); + }); + + Assert.Equal("patchCompiler", ex.ParamName); + } + + [Fact] + public void TestExtractPatch__ProtoPatchNull() + { + UrlDir.UrlConfig patchConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE"), root); + + protoPatchBuilder.Build(patchConfig, Command.Insert, Arg.Any()).Returns(null, new ProtoPatch[0]); + + Assert.Null(patchExtractor.ExtractPatch(patchConfig)); + + needsChecker.DidNotReceiveWithAnyArgs().CheckNeedsExpression(null); + + AssertNoErrors(); + + progress.DidNotReceive().PatchAdded(); + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedRoot(null); + } + + [Fact] + public void TestExtractPatch() + { + UrlDir.UrlConfig urlConfig = CreateConfig("@NODE_TYPE"); + + ITagList tagList = Substitute.For(); + tagListParser.Parse("NODE_TYPE", urlConfig).Returns(tagList); + + IPassSpecifier passSpecifier = Substitute.For(); + ProtoPatch protoPatch = new ProtoPatch( + urlConfig, + Command.Edit, + "NODE_TYPE", + "nodeName", + null, + "has", + passSpecifier + ); + + protoPatchBuilder.Build(urlConfig, Command.Edit, tagList).Returns(protoPatch); + passSpecifier.CheckNeeds(needsChecker, progress).Returns(true); + + IPatch patch = Substitute.For(); + patchCompiler.CompilePatch(protoPatch).Returns(patch); + + Assert.Same(patch, patchExtractor.ExtractPatch(urlConfig)); + + AssertNoErrors(); + + needsChecker.Received().CheckNeedsRecursive(urlConfig.config, urlConfig); + needsChecker.DidNotReceiveWithAnyArgs().CheckNeedsExpression(null); + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedRoot(null); + } + + [Fact] + public void TestExtractPatch__Needs() + { + UrlDir.UrlConfig urlConfig = CreateConfig("@NODE_TYPE"); + + ITagList tagList = Substitute.For(); + tagListParser.Parse("NODE_TYPE", urlConfig).Returns(tagList); + + IPassSpecifier passSpecifier = Substitute.For(); + ProtoPatch protoPatch = new ProtoPatch( + urlConfig, + Command.Edit, + "NODE_TYPE", + "nodeName", + "needs", + "has", + passSpecifier + ); + + protoPatchBuilder.Build(urlConfig, Command.Edit, tagList).Returns(protoPatch); + needsChecker.CheckNeedsExpression("needs").Returns(true); + passSpecifier.CheckNeeds(needsChecker, progress).Returns(true); + + IPatch patch = Substitute.For(); + patchCompiler.CompilePatch(protoPatch).Returns(patch); + + Assert.Same(patch, patchExtractor.ExtractPatch(urlConfig)); + + AssertNoErrors(); + + needsChecker.Received().CheckNeedsRecursive(urlConfig.config, urlConfig); + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedRoot(null); + } + + [Fact] + public void TestExtractPatch__NeedsUnsatisfied() + { + UrlDir.UrlConfig urlConfig = CreateConfig("@NODE_TYPE"); + + ITagList tagList = Substitute.For(); + tagListParser.Parse("NODE_TYPE", urlConfig).Returns(tagList); + + IPassSpecifier passSpecifier = Substitute.For(); + ProtoPatch protoPatch = new ProtoPatch( + urlConfig, + Command.Edit, + "NODE_TYPE", + "nodeName", + "needs", + "has", + passSpecifier + ); + + protoPatchBuilder.Build(urlConfig, Command.Edit, tagList).Returns(protoPatch); + needsChecker.CheckNeedsExpression("needs").Returns(false); + + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + AssertNoErrors(); + + passSpecifier.DidNotReceiveWithAnyArgs().CheckNeeds(null, null); + needsChecker.DidNotReceiveWithAnyArgs().CheckNeedsRecursive(null, null); + patchCompiler.DidNotReceiveWithAnyArgs().CompilePatch(null); + + progress.Received().NeedsUnsatisfiedRoot(urlConfig); + } + + [Fact] + public void TestExtractPatch__NeedsUnsatisfiedPassSpecifier() + { + UrlDir.UrlConfig urlConfig = CreateConfig("@NODE_TYPE"); + + ITagList tagList = Substitute.For(); + tagListParser.Parse("NODE_TYPE", urlConfig).Returns(tagList); + + IPassSpecifier passSpecifier = Substitute.For(); + ProtoPatch protoPatch = new ProtoPatch( + urlConfig, + Command.Edit, + "NODE_TYPE", + "nodeName", + "needs", + "has", + passSpecifier + ); + + protoPatchBuilder.Build(urlConfig, Command.Edit, tagList).Returns(protoPatch); + needsChecker.CheckNeedsExpression("needs").Returns(true); + passSpecifier.CheckNeeds(needsChecker, progress).Returns(false); + + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + AssertNoErrors(); + + needsChecker.DidNotReceiveWithAnyArgs().CheckNeedsRecursive(null, null); + patchCompiler.DidNotReceiveWithAnyArgs().CompilePatch(null); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedRoot(null); + } + + [Fact] + public void TestExtractPatch__Null() + { + ArgumentNullException ex = Assert.Throws(delegate + { + patchExtractor.ExtractPatch(null); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestExtractPatch__NotBracketBalanced() + { + UrlDir.UrlConfig config1 = CreateConfig("@NODE:FOR["); + UrlDir.UrlConfig config2 = CreateConfig("NODE:HAS[#foo[]"); + + patchExtractor.ExtractPatch(config1); + patchExtractor.ExtractPatch(config2); + + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + + Received.InOrder(delegate + { + progress.Received().Error(config1, "Error - node name does not have balanced brackets (or a space - if so replace with ?):\nabc/def/@NODE:FOR["); + progress.Received().Error(config2, "Error - node name does not have balanced brackets (or a space - if so replace with ?):\nabc/def/NODE:HAS[#foo[]"); + }); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedRoot(null); + } + + [Fact] + public void TestExtractPatch__InvalidCommand__Replace() + { + UrlDir.UrlConfig urlConfig = CreateConfig("%NODE"); + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + progress.Received().Error(urlConfig, "Error - replace command (%) is not valid on a root node: abc/def/%NODE"); + } + + [Fact] + public void TestExtractPatch__InvalidCommand__Create() + { + UrlDir.UrlConfig urlConfig = CreateConfig("&NODE"); + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + progress.Received().Error(urlConfig, "Error - create command (&) is not valid on a root node: abc/def/&NODE"); + } + + [Fact] + public void TestExtractPatch__InvalidCommand__Rename() + { + UrlDir.UrlConfig urlConfig = CreateConfig("|NODE"); + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + progress.Received().Error(urlConfig, "Error - rename command (|) is not valid on a root node: abc/def/|NODE"); + } + + [Fact] + public void TestExtractPatch__InvalidCommand__Paste() + { + UrlDir.UrlConfig urlConfig = CreateConfig("#NODE"); + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + progress.Received().Error(urlConfig, "Error - paste command (#) is not valid on a root node: abc/def/#NODE"); + } + + [Fact] + public void TestExtractPatch__InvalidCommand__Special() + { + UrlDir.UrlConfig urlConfig = CreateConfig("*NODE"); + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + progress.Received().Error(urlConfig, "Error - special command (*) is not valid on a root node: abc/def/*NODE"); + } + + [Fact] + public void TestExtractPatch__TagListBadlyFormatted() + { + UrlDir.UrlConfig urlConfig = CreateConfig("badSomehow"); + tagListParser.When(t => t.Parse("badSomehow", urlConfig)).Throw(new FormatException("badly formatted")); + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + progress.Received().Error(urlConfig, "Cannot parse node name as tag list: badly formatted\non: abc/def/badSomehow"); + } + + [Fact] + public void TestExtractPatch__ProtoPatchFailed() + { + UrlDir.UrlConfig urlConfig = CreateConfig("NODE"); + protoPatchBuilder.Build(urlConfig, Command.Insert, Arg.Any()).Returns((ProtoPatch)null); + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + AssertNoErrors(); + } + + [Fact] + public void TestExtractPatch__Exception() + { + UrlDir.UrlConfig urlConfig = CreateConfig("NODE"); + Exception ex = new Exception(); + tagListParser.When(t => t.Parse("NODE", urlConfig)).Throw(ex); + Assert.Null(patchExtractor.ExtractPatch(urlConfig)); + + progress.Received().Exception(urlConfig, "Exception while attempting to create patch from config: abc/def/NODE", ex); + } + + private UrlDir.UrlConfig CreateConfig(string name) + { + ConfigNode node = new TestConfigNode(name) + { + { "name", "snack" }, + { "cheese", "gouda" }, + { "bread", "sourdough" }, + new ConfigNode("wine"), + new ConfigNode("fruit"), + }; + + node.id = "hungry?"; + + return UrlBuilder.CreateConfig(node, file); + } + + private void AssertNoErrors() + { + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + } +} diff --git a/ModuleManagerTests/PatchListTest.cs b/ModuleManagerTests/PatchListTest.cs new file mode 100644 index 00000000..4dc5c751 --- /dev/null +++ b/ModuleManagerTests/PatchListTest.cs @@ -0,0 +1,223 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests +{ + public class PatchListTest + { + [Fact] + public void TestConstructor__ModListNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchList(null, new IPatch[0], Substitute.For()); + }); + + Assert.Equal("modList", ex.ParamName); + } + + [Fact] + public void TestConstructor__PatchesNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchList(new string[0], null, Substitute.For()); + }); + + Assert.Equal("patches", ex.ParamName); + } + + [Fact] + public void TestConstructor__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new PatchList(new string[0], new IPatch[0], null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestConstructor__UnknownMod() + { + IPatch patch = Substitute.For(); + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE")); + patch.PassSpecifier.Returns(new BeforePassSpecifier("mod3", urlConfig)); + IPatchProgress progress = Substitute.For(); + + KeyNotFoundException ex = Assert.Throws(delegate + { + new PatchList(new[] { "mod1", "mod2" }, new[] { patch }, progress); + }); + + Assert.Equal("Mod 'mod3' not found", ex.Message); + + progress.DidNotReceive().PatchAdded(); + } + + [Fact] + public void TestConstructor__UnknownPassSpecifier() + { + IPatch patch = Substitute.For(); + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE")); + IPassSpecifier passSpecifier = Substitute.For(); + passSpecifier.Descriptor.Returns(":SOMEPASS"); + patch.PassSpecifier.Returns(passSpecifier); + IPatchProgress progress = Substitute.For(); + + NotImplementedException ex = Assert.Throws(delegate + { + new PatchList(new string[0], new[] { patch }, progress); + }); + + Assert.Equal("Don't know what to do with pass specifier: :SOMEPASS", ex.Message); + + progress.DidNotReceive().PatchAdded(); + } + + [Fact] + public void Test__Lifecycle() + { + IPatch[] patches = new IPatch[] + { + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + Substitute.For(), + }; + + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE")); + + patches[00].PassSpecifier.Returns(new InsertPassSpecifier()); + patches[01].PassSpecifier.Returns(new InsertPassSpecifier()); + patches[02].PassSpecifier.Returns(new FirstPassSpecifier()); + patches[03].PassSpecifier.Returns(new FirstPassSpecifier()); + patches[04].PassSpecifier.Returns(new LegacyPassSpecifier()); + patches[05].PassSpecifier.Returns(new LegacyPassSpecifier()); + patches[06].PassSpecifier.Returns(new BeforePassSpecifier("mod1", urlConfig)); + patches[07].PassSpecifier.Returns(new BeforePassSpecifier("MOD1", urlConfig)); + patches[08].PassSpecifier.Returns(new ForPassSpecifier("mod1", urlConfig)); + patches[09].PassSpecifier.Returns(new ForPassSpecifier("MOD1", urlConfig)); + patches[10].PassSpecifier.Returns(new AfterPassSpecifier("mod1", urlConfig)); + patches[11].PassSpecifier.Returns(new AfterPassSpecifier("MOD1", urlConfig)); + patches[12].PassSpecifier.Returns(new LastPassSpecifier("mod1")); + patches[13].PassSpecifier.Returns(new LastPassSpecifier("MOD1")); + patches[14].PassSpecifier.Returns(new BeforePassSpecifier("mod2", urlConfig)); + patches[15].PassSpecifier.Returns(new BeforePassSpecifier("MOD2", urlConfig)); + patches[16].PassSpecifier.Returns(new ForPassSpecifier("mod2", urlConfig)); + patches[17].PassSpecifier.Returns(new ForPassSpecifier("MOD2", urlConfig)); + patches[18].PassSpecifier.Returns(new AfterPassSpecifier("mod2", urlConfig)); + patches[19].PassSpecifier.Returns(new AfterPassSpecifier("MOD2", urlConfig)); + patches[20].PassSpecifier.Returns(new LastPassSpecifier("mod2")); + patches[21].PassSpecifier.Returns(new LastPassSpecifier("MOD2")); + patches[22].PassSpecifier.Returns(new LastPassSpecifier("mod3")); + patches[23].PassSpecifier.Returns(new FinalPassSpecifier()); + patches[24].PassSpecifier.Returns(new FinalPassSpecifier()); + + patches[00].CountsAsPatch.Returns(false); + patches[01].CountsAsPatch.Returns(false); + patches[02].CountsAsPatch.Returns(true); + patches[03].CountsAsPatch.Returns(true); + patches[04].CountsAsPatch.Returns(true); + patches[05].CountsAsPatch.Returns(true); + patches[06].CountsAsPatch.Returns(true); + patches[07].CountsAsPatch.Returns(true); + patches[08].CountsAsPatch.Returns(true); + patches[09].CountsAsPatch.Returns(true); + patches[10].CountsAsPatch.Returns(true); + patches[11].CountsAsPatch.Returns(true); + patches[12].CountsAsPatch.Returns(true); + patches[13].CountsAsPatch.Returns(true); + patches[14].CountsAsPatch.Returns(true); + patches[15].CountsAsPatch.Returns(true); + patches[16].CountsAsPatch.Returns(true); + patches[17].CountsAsPatch.Returns(true); + patches[18].CountsAsPatch.Returns(true); + patches[19].CountsAsPatch.Returns(true); + patches[20].CountsAsPatch.Returns(true); + patches[21].CountsAsPatch.Returns(true); + patches[22].CountsAsPatch.Returns(true); + patches[23].CountsAsPatch.Returns(true); + patches[24].CountsAsPatch.Returns(true); + + IPatchProgress progress = Substitute.For(); + + PatchList patchList = new PatchList(new[] { "mod1", "mod2" }, patches, progress); + + IPass[] passes = patchList.ToArray(); + + Assert.Equal(13, passes.Length); + + Assert.Equal(":INSERT (initial)", passes[0].Name); + Assert.Equal(new[] { patches[0], patches[1] }, passes[0]); + + Assert.Equal(":FIRST", passes[1].Name); + Assert.Equal(new[] { patches[2], patches[3] }, passes[1]); + + Assert.Equal(":LEGACY (default)", passes[2].Name); + Assert.Equal(new[] { patches[4], patches[5] }, passes[2]); + + Assert.Equal(":BEFORE[MOD1]", passes[3].Name); + Assert.Equal(new[] { patches[6], patches[7] }, passes[3]); + + Assert.Equal(":FOR[MOD1]", passes[4].Name); + Assert.Equal(new[] { patches[8], patches[9] }, passes[4]); + + Assert.Equal(":AFTER[MOD1]", passes[5].Name); + Assert.Equal(new[] { patches[10], patches[11] }, passes[5]); + + Assert.Equal(":BEFORE[MOD2]", passes[6].Name); + Assert.Equal(new[] { patches[14], patches[15] }, passes[6]); + + Assert.Equal(":FOR[MOD2]", passes[7].Name); + Assert.Equal(new[] { patches[16], patches[17] }, passes[7]); + + Assert.Equal(":AFTER[MOD2]", passes[8].Name); + Assert.Equal(new[] { patches[18], patches[19] }, passes[8]); + + Assert.Equal(":LAST[MOD1]", passes[9].Name); + Assert.Equal(new[] { patches[12], patches[13] }, passes[9]); + + Assert.Equal(":LAST[MOD2]", passes[10].Name); + Assert.Equal(new[] { patches[20], patches[21] }, passes[10]); + + Assert.Equal(":LAST[MOD3]", passes[11].Name); + Assert.Equal(new[] { patches[22] }, passes[11]); + + Assert.Equal(":FINAL", passes[12].Name); + Assert.Equal(new[] { patches[23], patches[24] }, passes[12]); + + progress.Received(23).PatchAdded(); + } + } +} diff --git a/ModuleManagerTests/Patches/CopyPatchTest.cs b/ModuleManagerTests/Patches/CopyPatchTest.cs new file mode 100644 index 00000000..ee6443dd --- /dev/null +++ b/ModuleManagerTests/Patches/CopyPatchTest.cs @@ -0,0 +1,344 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class CopyPatchTest + { + [Fact] + public void TestConstructor__urlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new CopyPatch(null, Substitute.For(), Substitute.For()); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestConstructor__nodeMatcherNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new CopyPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), null, Substitute.For()); + }); + + Assert.Equal("nodeMatcher", ex.ParamName); + } + + [Fact] + public void TestConstructor__passSpecifierNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new CopyPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), null); + }); + + Assert.Equal("passSpecifier", ex.ParamName); + } + + [Fact] + public void TestUrlConfig() + { + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode()); + CopyPatch patch = new CopyPatch(urlConfig, Substitute.For(), Substitute.For()); + + Assert.Same(urlConfig, patch.UrlConfig); + } + + [Fact] + public void TestNodeMatcher() + { + INodeMatcher nodeMatcher = Substitute.For(); + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), nodeMatcher, Substitute.For()); + + Assert.Same(nodeMatcher, patch.NodeMatcher); + } + + [Fact] + public void TestPassSpecifier() + { + IPassSpecifier passSpecifier = Substitute.For(); + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), passSpecifier); + + Assert.Same(passSpecifier, patch.PassSpecifier); + } + + [Fact] + public void TestCountsAsPatch() + { + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + Assert.True(patch.CountsAsPatch); + } + + [Fact] + public void TestApply() + { + UrlDir.UrlFile file = UrlBuilder.CreateFile("abc/def.cfg"); + + ConfigNode config1 = new TestConfigNode("NODE") + { + { "foo", "bar" }, + }; + + ConfigNode config2 = new TestConfigNode("NODE") + { + { "foo", "bar" }, + }; + + ConfigNode config3 = new ConfigNode("NODE"); + ConfigNode config4 = new ConfigNode("NODE"); + + INodeMatcher nodeMatcher = Substitute.For(); + + nodeMatcher.IsMatch(config1).Returns(false); + nodeMatcher.IsMatch(config2).Returns(true); + nodeMatcher.IsMatch(config3).Returns(false); + nodeMatcher.IsMatch(config4).Returns(true); + + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("ghi/jkl", new TestConfigNode("@NODE") + { + { "@foo", "baz" }, + { "pqr", "stw" }, + }), nodeMatcher, Substitute.For()); + + IProtoUrlConfig protoUrlConfig1 = Substitute.For(); + IProtoUrlConfig protoUrlConfig2 = Substitute.For(); + IProtoUrlConfig protoUrlConfig3 = Substitute.For(); + IProtoUrlConfig protoUrlConfig4 = Substitute.For(); + + protoUrlConfig1.Node.Returns(config1); + protoUrlConfig2.Node.Returns(config2); + protoUrlConfig3.Node.Returns(config3); + protoUrlConfig4.Node.Returns(config4); + + protoUrlConfig1.UrlFile.Returns(file); + protoUrlConfig2.UrlFile.Returns(file); + protoUrlConfig3.UrlFile.Returns(file); + protoUrlConfig4.UrlFile.Returns(file); + + LinkedList configs = new LinkedList(); + configs.AddLast(protoUrlConfig1); + configs.AddLast(protoUrlConfig2); + configs.AddLast(protoUrlConfig3); + configs.AddLast(protoUrlConfig4); + + IPatchProgress progress = Substitute.For(); + IBasicLogger logger = Substitute.For(); + + patch.Apply(configs, progress, logger); + + IProtoUrlConfig[] newConfigs = configs.ToArray(); + + Assert.Equal(6, newConfigs.Length); + + Assert.Same(protoUrlConfig1, newConfigs[0]); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "foo", "bar" }, + }, newConfigs[0].Node); + + Assert.Same(protoUrlConfig2, newConfigs[1]); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "foo", "bar" }, + }, newConfigs[1].Node); + + AssertNodesEqual(new TestConfigNode("NODE") + { + { "foo", "baz" }, + { "pqr", "stw" }, + }, newConfigs[2].Node); + Assert.Same(file, newConfigs[2].UrlFile); + + Assert.Same(protoUrlConfig3, newConfigs[3]); + AssertNodesEqual(new ConfigNode("NODE"), newConfigs[3].Node); + + Assert.Same(protoUrlConfig4, newConfigs[4]); + AssertNodesEqual(new ConfigNode("NODE"), newConfigs[4].Node); + + AssertNodesEqual(new TestConfigNode("NODE") + { + { "pqr", "stw" }, + }, newConfigs[5].Node); + Assert.Same(file, newConfigs[5].UrlFile); + + Received.InOrder(delegate + { + progress.ApplyingCopy(protoUrlConfig2, patch.UrlConfig); + progress.ApplyingCopy(protoUrlConfig4, patch.UrlConfig); + }); + + progress.DidNotReceiveWithAnyArgs().ApplyingUpdate(null, null); + progress.DidNotReceiveWithAnyArgs().ApplyingDelete(null, null); + + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + + [Fact] + public void TestApply__NameChanged() + { + UrlDir.UrlFile file = UrlBuilder.CreateFile("abc/def.cfg"); + + ConfigNode config = new TestConfigNode("NODE") + { + { "name", "000" }, + { "foo", "bar" }, + }; + + INodeMatcher nodeMatcher = Substitute.For(); + + nodeMatcher.IsMatch(config).Returns(true); + + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("ghi/jkl", new TestConfigNode("@NODE") + { + { "@name", "001" }, + { "@foo", "baz" }, + { "pqr", "stw" }, + }), nodeMatcher, Substitute.For()); + + IProtoUrlConfig protoConfig = Substitute.For(); + protoConfig.Node.Returns(config); + protoConfig.UrlFile.Returns(file); + + LinkedList configs = new LinkedList(); + configs.AddLast(protoConfig); + + IPatchProgress progress = Substitute.For(); + IBasicLogger logger = Substitute.For(); + + patch.Apply(configs, progress, logger); + + IProtoUrlConfig[] newConfigs = configs.ToArray(); + + Assert.Equal(2, newConfigs.Length); + + Assert.Same(protoConfig, newConfigs[0]); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "name", "000" }, + { "foo", "bar" }, + }, newConfigs[0].Node); + + AssertNodesEqual(new TestConfigNode("NODE") + { + { "name", "001" }, + { "foo", "baz" }, + { "pqr", "stw" }, + }, newConfigs[1].Node); + Assert.Same(file, newConfigs[1].UrlFile); + + progress.Received().ApplyingCopy(protoConfig, patch.UrlConfig); + + progress.DidNotReceiveWithAnyArgs().ApplyingUpdate(null, null); + progress.DidNotReceiveWithAnyArgs().ApplyingDelete(null, null); + + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + + [Fact] + public void TestApply__NameNotChanged() + { + ConfigNode config = new TestConfigNode("NODE") + { + { "name", "000" }, + { "foo", "bar" }, + }; + + INodeMatcher nodeMatcher = Substitute.For(); + + nodeMatcher.IsMatch(config).Returns(true); + + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("ghi/jkl", new TestConfigNode("+NODE") + { + { "@foo", "baz" }, + { "pqr", "stw" }, + }), nodeMatcher, Substitute.For()); + + IProtoUrlConfig protoConfig = Substitute.For(); + protoConfig.Node.Returns(config); + protoConfig.FullUrl.Returns("abc/def.cfg/NODE"); + + LinkedList configs = new LinkedList(); + configs.AddLast(protoConfig); + + IPatchProgress progress = Substitute.For(); + IBasicLogger logger = Substitute.For(); + + patch.Apply(configs, progress, logger); + + Assert.Single(configs); + + Assert.Same(protoConfig, configs.First.Value); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "name", "000" }, + { "foo", "bar" }, + }, configs.First.Value.Node); + + progress.Received().Error(patch.UrlConfig, "Error - when applying copy ghi/jkl/+NODE to abc/def.cfg/NODE - the copy needs to have a different name than the parent (use @name = xxx)"); + + progress.DidNotReceiveWithAnyArgs().ApplyingUpdate(null, null); + progress.DidNotReceiveWithAnyArgs().ApplyingCopy(null, null); + progress.DidNotReceiveWithAnyArgs().ApplyingDelete(null, null); + + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + + [Fact] + public void TestApply__DatabaseConfigsNullNull() + { + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(null, Substitute.For(), Substitute.For()); + }); + + Assert.Equal("databaseConfigs", ex.ParamName); + } + + [Fact] + public void TestApply__ProgressNull() + { + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(new LinkedList(), null, Substitute.For()); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestApply__LoggerNull() + { + CopyPatch patch = new CopyPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(new LinkedList(), Substitute.For(), null); + }); + + Assert.Equal("logger", ex.ParamName); + } + + private void AssertNodesEqual(ConfigNode expected, ConfigNode actual) + { + Assert.Equal(expected.ToString(), actual.ToString()); + } + } +} diff --git a/ModuleManagerTests/Patches/DeletePatchTest.cs b/ModuleManagerTests/Patches/DeletePatchTest.cs new file mode 100644 index 00000000..f45916fa --- /dev/null +++ b/ModuleManagerTests/Patches/DeletePatchTest.cs @@ -0,0 +1,173 @@ +using System; +using System.Collections.Generic; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class DeletePatchTest + { + [Fact] + public void TestConstructor__urlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new DeletePatch(null, Substitute.For(), Substitute.For()); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestConstructor__nodeMatcherNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new DeletePatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), null, Substitute.For()); + }); + + Assert.Equal("nodeMatcher", ex.ParamName); + } + + [Fact] + public void TestConstructor__passSpecifierNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new DeletePatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), null); + }); + + Assert.Equal("passSpecifier", ex.ParamName); + } + + [Fact] + public void TestUrlConfig() + { + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode()); + DeletePatch patch = new DeletePatch(urlConfig, Substitute.For(), Substitute.For()); + + Assert.Same(urlConfig, patch.UrlConfig); + } + + [Fact] + public void TestNodeMatcher() + { + INodeMatcher nodeMatcher = Substitute.For(); + DeletePatch patch = new DeletePatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), nodeMatcher, Substitute.For()); + + Assert.Same(nodeMatcher, patch.NodeMatcher); + } + + [Fact] + public void TestPassSpecifier() + { + IPassSpecifier passSpecifier = Substitute.For(); + DeletePatch patch = new DeletePatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), passSpecifier); + + Assert.Same(passSpecifier, patch.PassSpecifier); + } + + [Fact] + public void TestCountsAsPatch() + { + DeletePatch patch = new DeletePatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + Assert.True(patch.CountsAsPatch); + } + + [Fact] + public void TestApply() + { + ConfigNode config1 = new ConfigNode("NODE"); + ConfigNode config2 = new ConfigNode("NODE"); + ConfigNode config3 = new ConfigNode("NODE"); + ConfigNode config4 = new ConfigNode("NODE"); + + INodeMatcher nodeMatcher = Substitute.For(); + + nodeMatcher.IsMatch(config1).Returns(false); + nodeMatcher.IsMatch(config2).Returns(true); + nodeMatcher.IsMatch(config3).Returns(false); + nodeMatcher.IsMatch(config4).Returns(true); + + DeletePatch patch = new DeletePatch(UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("!NODE")), nodeMatcher, Substitute.For()); + + IProtoUrlConfig urlConfig1 = Substitute.For(); + IProtoUrlConfig urlConfig2 = Substitute.For(); + IProtoUrlConfig urlConfig3 = Substitute.For(); + IProtoUrlConfig urlConfig4 = Substitute.For(); + + urlConfig1.Node.Returns(config1); + urlConfig2.Node.Returns(config2); + urlConfig3.Node.Returns(config3); + urlConfig4.Node.Returns(config4); + + LinkedList configs = new LinkedList(); + configs.AddLast(urlConfig1); + configs.AddLast(urlConfig2); + configs.AddLast(urlConfig3); + configs.AddLast(urlConfig4); + + IPatchProgress progress = Substitute.For(); + IBasicLogger logger = Substitute.For(); + + patch.Apply(configs, progress, logger); + + Assert.Equal(new[] { urlConfig1, urlConfig3 }, configs); + + Received.InOrder(delegate + { + progress.ApplyingDelete(urlConfig2, patch.UrlConfig); + progress.ApplyingDelete(urlConfig4, patch.UrlConfig); + }); + + progress.DidNotReceiveWithAnyArgs().ApplyingUpdate(null, null); + progress.DidNotReceiveWithAnyArgs().ApplyingCopy(null, null); + + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + + [Fact] + public void TestApply__DatabaseConfigsNull() + { + DeletePatch patch = new DeletePatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(null, Substitute.For(), Substitute.For()); + }); + + Assert.Equal("databaseConfigs", ex.ParamName); + } + + [Fact] + public void TestApply__ProgressNull() + { + DeletePatch patch = new DeletePatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(new LinkedList(), null, Substitute.For()); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestApply__LoggerNull() + { + DeletePatch patch = new DeletePatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(new LinkedList(), Substitute.For(), null); + }); + + Assert.Equal("logger", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/Patches/EditPatchTest.cs b/ModuleManagerTests/Patches/EditPatchTest.cs new file mode 100644 index 00000000..7c76cf48 --- /dev/null +++ b/ModuleManagerTests/Patches/EditPatchTest.cs @@ -0,0 +1,295 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Xunit; +using NSubstitute; +using UnityEngine; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class EditPatchTest + { + [Fact] + public void TestConstructor__urlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new EditPatch(null, Substitute.For(), Substitute.For()); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestConstructor__nodeMatcherNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), null, Substitute.For()); + }); + + Assert.Equal("nodeMatcher", ex.ParamName); + } + + [Fact] + public void TestConstructor__passSpecifierNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), null); + }); + + Assert.Equal("passSpecifier", ex.ParamName); + } + + [Fact] + public void TestUrlConfig() + { + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode()); + EditPatch patch = new EditPatch(urlConfig, Substitute.For(), Substitute.For()); + + Assert.Same(urlConfig, patch.UrlConfig); + } + + [Fact] + public void TestNodeMatcher() + { + INodeMatcher nodeMatcher = Substitute.For(); + EditPatch patch = new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), nodeMatcher, Substitute.For()); + + Assert.Same(nodeMatcher, patch.NodeMatcher); + } + + [Fact] + public void TestPassSpecifier() + { + IPassSpecifier passSpecifier = Substitute.For(); + EditPatch patch = new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), passSpecifier); + + Assert.Same(passSpecifier, patch.PassSpecifier); + } + + [Fact] + public void TestCountsAsPatch() + { + EditPatch patch = new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + Assert.True(patch.CountsAsPatch); + } + + [Fact] + public void TestApply() + { + UrlDir.UrlFile file = UrlBuilder.CreateFile("abc/def.cfg"); + + ConfigNode config1 = new TestConfigNode("NODE") + { + { "foo", "bar" }, + }; + + ConfigNode config2 = new TestConfigNode("NODE") + { + { "foo", "bar" }, + }; + + ConfigNode config3 = new ConfigNode("NODE"); + ConfigNode config4 = new ConfigNode("NODE"); + + INodeMatcher nodeMatcher = Substitute.For(); + + nodeMatcher.IsMatch(config1).Returns(false); + nodeMatcher.IsMatch(config2).Returns(true); + nodeMatcher.IsMatch(config3).Returns(false); + nodeMatcher.IsMatch(config4).Returns(true); + + EditPatch patch = new EditPatch(UrlBuilder.CreateConfig("ghi/jkl", new TestConfigNode("@NODE") + { + { "@foo", "baz" }, + { "pqr", "stw" }, + }), nodeMatcher, Substitute.For()); + + IProtoUrlConfig urlConfig1 = Substitute.For(); + IProtoUrlConfig urlConfig2 = Substitute.For(); + IProtoUrlConfig urlConfig3 = Substitute.For(); + IProtoUrlConfig urlConfig4 = Substitute.For(); + + urlConfig1.Node.Returns(config1); + urlConfig2.Node.Returns(config2); + urlConfig3.Node.Returns(config3); + urlConfig4.Node.Returns(config4); + + urlConfig1.UrlFile.Returns(file); + urlConfig2.UrlFile.Returns(file); + urlConfig3.UrlFile.Returns(file); + urlConfig4.UrlFile.Returns(file); + + LinkedList configs = new LinkedList(); + configs.AddLast(urlConfig1); + configs.AddLast(urlConfig2); + configs.AddLast(urlConfig3); + configs.AddLast(urlConfig4); + + IPatchProgress progress = Substitute.For(); + IBasicLogger logger = Substitute.For(); + + patch.Apply(configs, progress, logger); + + IProtoUrlConfig[] newConfigs = configs.ToArray(); + + Assert.Equal(4, newConfigs.Length); + + Assert.Same(urlConfig1, newConfigs[0]); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "foo", "bar" }, + }, newConfigs[0].Node); + + AssertNodesEqual(new TestConfigNode("NODE") + { + { "foo", "baz" }, + { "pqr", "stw" }, + }, newConfigs[1].Node); + Assert.Same(file, newConfigs[1].UrlFile); + + Assert.Same(urlConfig3, newConfigs[2]); + AssertNodesEqual(new ConfigNode("NODE"), newConfigs[2].Node); + + AssertNodesEqual(new TestConfigNode("NODE") + { + { "pqr", "stw" }, + }, newConfigs[3].Node); + Assert.Same(file, newConfigs[3].UrlFile); + + Received.InOrder(delegate + { + progress.ApplyingUpdate(urlConfig2, patch.UrlConfig); + progress.ApplyingUpdate(urlConfig4, patch.UrlConfig); + }); + + progress.DidNotReceiveWithAnyArgs().ApplyingCopy(null, null); + progress.DidNotReceiveWithAnyArgs().ApplyingDelete(null, null); + + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + + [Fact] + public void TestApply__Loop() + { + UrlDir.UrlFile file = UrlBuilder.CreateFile("abc/def.cfg"); + + ConfigNode config = new TestConfigNode("NODE") + { + { "name", "000" }, + { "aaa", "1" }, + }; + + INodeMatcher nodeMatcher = Substitute.For(); + + nodeMatcher.IsMatch(Arg.Is(node => int.Parse(node.GetValue("aaa")) < 10)).Returns(true); + + EditPatch patch = new EditPatch(UrlBuilder.CreateConfig("ghi/jkl", new TestConfigNode("@NODE") + { + { "@aaa *", "2" }, + { "bbb", "002" }, + new ConfigNode("MM_PATCH_LOOP"), + }), nodeMatcher, Substitute.For()); + + IProtoUrlConfig urlConfig = Substitute.For(); + urlConfig.Node.Returns(config); + urlConfig.UrlFile.Returns(file); + urlConfig.FullUrl.Returns("abc/def.cfg/NODE"); + + LinkedList configs = new LinkedList(); + configs.AddLast(urlConfig); + + IPatchProgress progress = Substitute.For(); + IBasicLogger logger = Substitute.For(); + + List modifiedUrlConfigs = new List(); + progress.ApplyingUpdate(Arg.Do(url => modifiedUrlConfigs.Add(url)), patch.UrlConfig); + + patch.Apply(configs, progress, logger); + + Assert.Single(configs); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "name", "000" }, + { "aaa", "16" }, + { "bbb", "002" }, + { "bbb", "002" }, + { "bbb", "002" }, + { "bbb", "002" }, + }, configs.First.Value.Node); + Assert.Same(file, configs.First.Value.UrlFile); + + Assert.Same(urlConfig, modifiedUrlConfigs[0]); + Assert.NotSame(urlConfig, modifiedUrlConfigs[1]); + Assert.NotSame(urlConfig, modifiedUrlConfigs[2]); + Assert.NotSame(urlConfig, modifiedUrlConfigs[3]); + + Received.InOrder(delegate + { + logger.AssertInfo("Looping on ghi/jkl/@NODE to abc/def.cfg/NODE"); + progress.ApplyingUpdate(urlConfig, patch.UrlConfig); + progress.ApplyingUpdate(modifiedUrlConfigs[1], patch.UrlConfig); + progress.ApplyingUpdate(modifiedUrlConfigs[2], patch.UrlConfig); + progress.ApplyingUpdate(modifiedUrlConfigs[3], patch.UrlConfig); + }); + + progress.DidNotReceiveWithAnyArgs().ApplyingCopy(null, null); + progress.DidNotReceiveWithAnyArgs().ApplyingDelete(null, null); + + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + + [Fact] + public void TestApply__DatabaseConfigsNull() + { + EditPatch patch = new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(null, Substitute.For(), Substitute.For()); + }); + + Assert.Equal("databaseConfigs", ex.ParamName); + } + + [Fact] + public void TestApply__ProgressNull() + { + EditPatch patch = new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(new LinkedList(), null, Substitute.For()); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestApply__LoggerNull() + { + EditPatch patch = new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For(), Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(new LinkedList(), Substitute.For(), null); + }); + + Assert.Equal("logger", ex.ParamName); + } + + private void AssertNodesEqual(ConfigNode expected, ConfigNode actual) + { + Assert.Equal(expected.ToString(), actual.ToString()); + } + } +} diff --git a/ModuleManagerTests/Patches/InsertPatchTest.cs b/ModuleManagerTests/Patches/InsertPatchTest.cs new file mode 100644 index 00000000..f1e134a4 --- /dev/null +++ b/ModuleManagerTests/Patches/InsertPatchTest.cs @@ -0,0 +1,180 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + + +namespace ModuleManagerTests.Patches +{ + public class InsertPatchTest + { + [Fact] + public void TestConstructor__UrlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new InsertPatch(null, "A_NODE", Substitute.For()); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestConstructor__NodeTypeNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), null, Substitute.For()); + }); + + Assert.Equal("nodeType", ex.ParamName); + } + + [Fact] + public void TestConstructor__PassSpecifierNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), "A_NODE", null); + }); + + Assert.Equal("passSpecifier", ex.ParamName); + } + + [Fact] + public void TestUrlConfig() + { + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode()); + InsertPatch patch = new InsertPatch(urlConfig, "A_NODE", Substitute.For()); + + Assert.Same(urlConfig, patch.UrlConfig); + } + + [Fact] + public void TestNodeType() + { + InsertPatch patch = new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), "A_NODE", Substitute.For()); + + Assert.Equal("A_NODE", patch.NodeType); + } + + [Fact] + public void TestPassSpecifier() + { + IPassSpecifier passSpecifier = Substitute.For(); + InsertPatch patch = new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), "A_NODE", passSpecifier); + + Assert.Same(passSpecifier, patch.PassSpecifier); + } + + [Fact] + public void TestCountsAsPatch() + { + InsertPatch patch = new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), "A_NODE", Substitute.For()); + Assert.False(patch.CountsAsPatch); + } + + [Fact] + public void TestApply() + { + UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new TestConfigNode("A_NODE:NEEDS[someMod]:FOR[somePass]") + { + { "key1", "value1" }, + { "key2", "value2" }, + new TestConfigNode("NODE_1") + { + { "key3", "value3" }, + }, + new TestConfigNode("NODE_2") + { + { "key4", "value4" }, + }, + }); + + InsertPatch patch = new InsertPatch(urlConfig, "A_NODE", Substitute.For()); + + LinkedList databaseConfigs = new LinkedList(); + + IProtoUrlConfig config1 = Substitute.For(); + IProtoUrlConfig config2 = Substitute.For(); + + databaseConfigs.AddLast(config1); + databaseConfigs.AddLast(config2); + + patch.Apply(databaseConfigs, Substitute.For(), Substitute.For()); + + IProtoUrlConfig[] databaseConfigsArray = databaseConfigs.ToArray(); + Assert.Equal(3, databaseConfigsArray.Length); + Assert.Same(config1, databaseConfigsArray[0]); + Assert.Same(config2, databaseConfigsArray[1]); + + Assert.Same(urlConfig.parent, databaseConfigsArray[2].UrlFile); + Assert.Equal("abc/def.cfg", databaseConfigsArray[2].FileUrl); + Assert.Equal("A_NODE", databaseConfigsArray[2].NodeType); + Assert.Equal("abc/def.cfg/A_NODE", databaseConfigsArray[2].FullUrl); + + Assert.NotSame(urlConfig.config, databaseConfigsArray[2].Node); + Assert.Equal("A_NODE", databaseConfigsArray[2].Node.name); + Assert.Equal("A_NODE:NEEDS[someMod]:FOR[somePass]", urlConfig.config.name); // make sure this hasn't been changed + Assert.Equal(2, databaseConfigsArray[2].Node.values.Count); + Assert.Equal("key1", databaseConfigsArray[2].Node.values[0].name); + Assert.Equal("value1", databaseConfigsArray[2].Node.values[0].value); + Assert.Equal("key2", databaseConfigsArray[2].Node.values[1].name); + Assert.Equal("value2", databaseConfigsArray[2].Node.values[1].value); + Assert.Equal(2, databaseConfigsArray[2].Node.nodes.Count); + Assert.Equal("NODE_1", databaseConfigsArray[2].Node.nodes[0].name); + Assert.Equal(1, databaseConfigsArray[2].Node.nodes[0].values.Count); + Assert.Equal("key3", databaseConfigsArray[2].Node.nodes[0].values[0].name); + Assert.Equal("value3", databaseConfigsArray[2].Node.nodes[0].values[0].value); + Assert.Equal(0, databaseConfigsArray[2].Node.nodes[0].nodes.Count); + Assert.Equal("NODE_2", databaseConfigsArray[2].Node.nodes[1].name); + Assert.Equal(1, databaseConfigsArray[2].Node.nodes[1].values.Count); + Assert.Equal("key4", databaseConfigsArray[2].Node.nodes[1].values[0].name); + Assert.Equal("value4", databaseConfigsArray[2].Node.nodes[1].values[0].value); + Assert.Equal(0, databaseConfigsArray[2].Node.nodes[1].nodes.Count); + } + + [Fact] + public void TestApply__DatabaseConfigsNull() + { + InsertPatch patch = new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), "A_NODE", Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(null, Substitute.For(), Substitute.For()); + }); + + Assert.Equal("configs", ex.ParamName); + } + + [Fact] + public void TestApply__ProgressNull() + { + InsertPatch patch = new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), "A_NODE", Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(new LinkedList(), null, Substitute.For()); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestApply__LoggerNull() + { + InsertPatch patch = new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), "A_NODE", Substitute.For()); + ArgumentNullException ex = Assert.Throws(delegate + { + patch.Apply(new LinkedList(), Substitute.For(), null); + }); + + Assert.Equal("logger", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/Patches/PassSpecifiers/AfterPassSpecifierTest.cs b/ModuleManagerTests/Patches/PassSpecifiers/AfterPassSpecifierTest.cs new file mode 100644 index 00000000..6e086b57 --- /dev/null +++ b/ModuleManagerTests/Patches/PassSpecifiers/AfterPassSpecifierTest.cs @@ -0,0 +1,105 @@ +using System; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class AfterPassSpecifierTest + { + public readonly UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE")); + public readonly INeedsChecker needsChecker = Substitute.For(); + public readonly IPatchProgress progress = Substitute.For(); + public readonly AfterPassSpecifier passSpecifier; + + public AfterPassSpecifierTest() + { + passSpecifier = new AfterPassSpecifier("mod1", urlConfig); + } + + [Fact] + public void TestConstructor__ModNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new AfterPassSpecifier(null, urlConfig); + }); + + Assert.Equal("mod", ex.ParamName); + } + + [Fact] + public void TestConstructor__ModEmpty() + { + ArgumentException ex = Assert.Throws(delegate + { + new AfterPassSpecifier("", urlConfig); + }); + + Assert.Equal("mod", ex.ParamName); + Assert.Contains("can't be empty", ex.Message); + } + + [Fact] + public void TestConstructor__UrlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new AfterPassSpecifier("mod1", null); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestCheckNeeds__False() + { + needsChecker.CheckNeeds("mod1").Returns(false); + Assert.False(passSpecifier.CheckNeeds(needsChecker, progress)); + + progress.Received().NeedsUnsatisfiedAfter(urlConfig); + } + + [Fact] + public void TestCheckNeeds__True() + { + needsChecker.CheckNeeds("mod1").Returns(true); + Assert.True(passSpecifier.CheckNeeds(needsChecker, progress)); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedAfter(null); + } + + [Fact] + public void TestCheckNeeds__NeedsCheckerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(null, progress); + }); + + Assert.Equal("needsChecker", ex.ParamName); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedAfter(null); + } + + [Fact] + public void TestCheckNeeds__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(needsChecker, null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestDescriptor() + { + Assert.Equal(":AFTER[MOD1]", passSpecifier.Descriptor); + } + } +} diff --git a/ModuleManagerTests/Patches/PassSpecifiers/BeforePassSpecifierTest.cs b/ModuleManagerTests/Patches/PassSpecifiers/BeforePassSpecifierTest.cs new file mode 100644 index 00000000..937da7c2 --- /dev/null +++ b/ModuleManagerTests/Patches/PassSpecifiers/BeforePassSpecifierTest.cs @@ -0,0 +1,105 @@ +using System; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches.PassSpecifiers +{ + public class BeforePassSpecifierTest + { + public readonly UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE")); + public readonly INeedsChecker needsChecker = Substitute.For(); + public readonly IPatchProgress progress = Substitute.For(); + public readonly BeforePassSpecifier passSpecifier; + + public BeforePassSpecifierTest() + { + passSpecifier = new BeforePassSpecifier("mod1", urlConfig); + } + + [Fact] + public void TestConstructor__ModNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new BeforePassSpecifier(null, urlConfig); + }); + + Assert.Equal("mod", ex.ParamName); + } + + [Fact] + public void TestConstructor__ModEmpty() + { + ArgumentException ex = Assert.Throws(delegate + { + new BeforePassSpecifier("", urlConfig); + }); + + Assert.Equal("mod", ex.ParamName); + Assert.Contains("can't be empty", ex.Message); + } + + [Fact] + public void TestConstructor__UrlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new BeforePassSpecifier("mod1", null); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestCheckNeeds__False() + { + needsChecker.CheckNeeds("mod1").Returns(false); + Assert.False(passSpecifier.CheckNeeds(needsChecker, progress)); + + progress.Received().NeedsUnsatisfiedBefore(urlConfig); + } + + [Fact] + public void TestCheckNeeds__True() + { + needsChecker.CheckNeeds("mod1").Returns(true); + Assert.True(passSpecifier.CheckNeeds(needsChecker, progress)); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedBefore(null); + } + + [Fact] + public void TestCheckNeeds__NeedsCheckerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(null, progress); + }); + + Assert.Equal("needsChecker", ex.ParamName); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedBefore(null); + } + + [Fact] + public void TestCheckNeeds__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(needsChecker, null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestDescriptor() + { + Assert.Equal(":BEFORE[MOD1]", passSpecifier.Descriptor); + } + } +} diff --git a/ModuleManagerTests/Patches/PassSpecifiers/FinalPassSpecifierTest.cs b/ModuleManagerTests/Patches/PassSpecifiers/FinalPassSpecifierTest.cs new file mode 100644 index 00000000..74b90123 --- /dev/null +++ b/ModuleManagerTests/Patches/PassSpecifiers/FinalPassSpecifierTest.cs @@ -0,0 +1,52 @@ +using System; +using Xunit; +using NSubstitute; +using ModuleManager; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class FinalPassSpecifierrTest + { + public readonly INeedsChecker needsChecker = Substitute.For(); + public readonly IPatchProgress progress = Substitute.For(); + private readonly FinalPassSpecifier passSpecifier = new FinalPassSpecifier(); + + [Fact] + public void TestCheckNeeds() + { + Assert.True(passSpecifier.CheckNeeds(needsChecker, progress)); + } + + [Fact] + public void TestCheckNeeds__NeedsCheckerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(null, progress); + }); + + Assert.Equal("needsChecker", ex.ParamName); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedAfter(null); + } + + [Fact] + public void TestCheckNeeds__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(needsChecker, null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestDescriptor() + { + Assert.Equal(":FINAL", passSpecifier.Descriptor); + } + } +} diff --git a/ModuleManagerTests/Patches/PassSpecifiers/FirstPassSpecifierTest.cs b/ModuleManagerTests/Patches/PassSpecifiers/FirstPassSpecifierTest.cs new file mode 100644 index 00000000..e8d22151 --- /dev/null +++ b/ModuleManagerTests/Patches/PassSpecifiers/FirstPassSpecifierTest.cs @@ -0,0 +1,52 @@ +using System; +using Xunit; +using NSubstitute; +using ModuleManager; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class FirstPassSpecifierTest + { + public readonly INeedsChecker needsChecker = Substitute.For(); + public readonly IPatchProgress progress = Substitute.For(); + private readonly FirstPassSpecifier passSpecifier = new FirstPassSpecifier(); + + [Fact] + public void TestCheckNeeds() + { + Assert.True(passSpecifier.CheckNeeds(needsChecker, progress)); + } + + [Fact] + public void TestCheckNeeds__NeedsCheckerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(null, progress); + }); + + Assert.Equal("needsChecker", ex.ParamName); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedAfter(null); + } + + [Fact] + public void TestCheckNeeds__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(needsChecker, null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestDescriptor() + { + Assert.Equal(":FIRST", passSpecifier.Descriptor); + } + } +} diff --git a/ModuleManagerTests/Patches/PassSpecifiers/ForPassSpecifierTest.cs b/ModuleManagerTests/Patches/PassSpecifiers/ForPassSpecifierTest.cs new file mode 100644 index 00000000..cec25628 --- /dev/null +++ b/ModuleManagerTests/Patches/PassSpecifiers/ForPassSpecifierTest.cs @@ -0,0 +1,105 @@ +using System; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class ForPassSpecifierTest + { + public readonly UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE")); + public readonly INeedsChecker needsChecker = Substitute.For(); + public readonly IPatchProgress progress = Substitute.For(); + public readonly ForPassSpecifier passSpecifier; + + public ForPassSpecifierTest() + { + passSpecifier = new ForPassSpecifier("mod1", urlConfig); + } + + [Fact] + public void TestConstructor__ModNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new ForPassSpecifier(null, urlConfig); + }); + + Assert.Equal("mod", ex.ParamName); + } + + [Fact] + public void TestConstructor__ModEmpty() + { + ArgumentException ex = Assert.Throws(delegate + { + new ForPassSpecifier("", urlConfig); + }); + + Assert.Equal("mod", ex.ParamName); + Assert.Contains("can't be empty", ex.Message); + } + + [Fact] + public void TestConstructor__UrlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new ForPassSpecifier("mod1", null); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestCheckNeeds__False() + { + needsChecker.CheckNeeds("mod1").Returns(false); + Assert.False(passSpecifier.CheckNeeds(needsChecker, progress)); + + progress.Received().NeedsUnsatisfiedFor(urlConfig); + } + + [Fact] + public void TestCheckNeeds__True() + { + needsChecker.CheckNeeds("mod1").Returns(true); + Assert.True(passSpecifier.CheckNeeds(needsChecker, progress)); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedFor(null); + } + + [Fact] + public void TestCheckNeeds__NeedsCheckerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(null, progress); + }); + + Assert.Equal("needsChecker", ex.ParamName); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedFor(null); + } + + [Fact] + public void TestCheckNeeds__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(needsChecker, null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestDescriptor() + { + Assert.Equal(":FOR[MOD1]", passSpecifier.Descriptor); + } + } +} diff --git a/ModuleManagerTests/Patches/PassSpecifiers/InsertPassSpecifierTest.cs b/ModuleManagerTests/Patches/PassSpecifiers/InsertPassSpecifierTest.cs new file mode 100644 index 00000000..9c6cccf1 --- /dev/null +++ b/ModuleManagerTests/Patches/PassSpecifiers/InsertPassSpecifierTest.cs @@ -0,0 +1,52 @@ +using System; +using Xunit; +using NSubstitute; +using ModuleManager; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class InsertPassSpecifierTest + { + public readonly INeedsChecker needsChecker = Substitute.For(); + public readonly IPatchProgress progress = Substitute.For(); + private readonly InsertPassSpecifier passSpecifier = new InsertPassSpecifier(); + + [Fact] + public void TestCheckNeeds() + { + Assert.True(passSpecifier.CheckNeeds(needsChecker, progress)); + } + + [Fact] + public void TestCheckNeeds__NeedsCheckerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(null, progress); + }); + + Assert.Equal("needsChecker", ex.ParamName); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedAfter(null); + } + + [Fact] + public void TestCheckNeeds__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(needsChecker, null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestDescriptor() + { + Assert.Equal(":INSERT (initial)", passSpecifier.Descriptor); + } + } +} diff --git a/ModuleManagerTests/Patches/PassSpecifiers/LastPassSpecifierTest.cs b/ModuleManagerTests/Patches/PassSpecifiers/LastPassSpecifierTest.cs new file mode 100644 index 00000000..bdf6bee5 --- /dev/null +++ b/ModuleManagerTests/Patches/PassSpecifiers/LastPassSpecifierTest.cs @@ -0,0 +1,58 @@ +using System; +using Xunit; +using NSubstitute; +using ModuleManager; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class LastPassSpecifierTest + { + public readonly INeedsChecker needsChecker = Substitute.For(); + public readonly IPatchProgress progress = Substitute.For(); + public readonly LastPassSpecifier passSpecifier; + + public LastPassSpecifierTest() + { + passSpecifier = new LastPassSpecifier("mod1"); + } + + [Fact] + public void TestConstructor__ModNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new LastPassSpecifier(null); + }); + + Assert.Equal("mod", ex.ParamName); + } + + [Fact] + public void TestConstructor__ModEmpty() + { + ArgumentException ex = Assert.Throws(delegate + { + new LastPassSpecifier(""); + }); + + Assert.Equal("mod", ex.ParamName); + Assert.Contains("can't be empty", ex.Message); + } + + [Fact] + public void TestCheckNeeds() + { + passSpecifier.CheckNeeds(needsChecker, progress); + + needsChecker.DidNotReceiveWithAnyArgs().CheckNeeds(null); + } + + [Fact] + public void TestDescriptor() + { + Assert.Equal(":LAST[MOD1]", passSpecifier.Descriptor); + } + } +} diff --git a/ModuleManagerTests/Patches/PassSpecifiers/LegacyPassSpecifierTest.cs b/ModuleManagerTests/Patches/PassSpecifiers/LegacyPassSpecifierTest.cs new file mode 100644 index 00000000..e565655c --- /dev/null +++ b/ModuleManagerTests/Patches/PassSpecifiers/LegacyPassSpecifierTest.cs @@ -0,0 +1,52 @@ +using System; +using Xunit; +using NSubstitute; +using ModuleManager; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class LegacyPassSpecifierTest + { + public readonly INeedsChecker needsChecker = Substitute.For(); + public readonly IPatchProgress progress = Substitute.For(); + private readonly LegacyPassSpecifier passSpecifier = new LegacyPassSpecifier(); + + [Fact] + public void TestCheckNeeds() + { + Assert.True(passSpecifier.CheckNeeds(needsChecker, progress)); + } + + [Fact] + public void TestCheckNeeds__NeedsCheckerNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(null, progress); + }); + + Assert.Equal("needsChecker", ex.ParamName); + + progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedAfter(null); + } + + [Fact] + public void TestCheckNeeds__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + passSpecifier.CheckNeeds(needsChecker, null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestDescriptor() + { + Assert.Equal(":LEGACY (default)", passSpecifier.Descriptor); + } + } +} diff --git a/ModuleManagerTests/Patches/PatchCompilerTest.cs b/ModuleManagerTests/Patches/PatchCompilerTest.cs new file mode 100644 index 00000000..bb786dc5 --- /dev/null +++ b/ModuleManagerTests/Patches/PatchCompilerTest.cs @@ -0,0 +1,369 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; + +namespace ModuleManagerTests.Patches +{ + public class PatchCompilerTest + { + private readonly IPatchProgress progress = Substitute.For(); + private readonly IBasicLogger logger = Substitute.For(); + private readonly UrlDir.UrlFile file = UrlBuilder.CreateFile("abc/def.cfg"); + private readonly PatchCompiler patchCompiler = new PatchCompiler(); + + [Fact] + public void TestCompilePatch__Insert() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig(new TestConfigNode("NODEE") + { + { "name", "foo" }, + { "bar", "bleh" }, + }, file), + Command.Insert, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + InsertPatch patch = Assert.IsType(patchCompiler.CompilePatch(protoPatch)); + + Assert.Same(protoPatch.urlConfig, patch.UrlConfig); + + LinkedList configs = new LinkedList(); + + patch.Apply(configs, progress, logger); + + Assert.Single(configs); + Assert.NotSame(protoPatch.urlConfig.config, configs.First.Value.Node); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "name", "foo" }, + { "bar", "bleh" }, + }, configs.First.Value.Node); + Assert.Same(file, configs.First.Value.UrlFile); + } + + [Fact] + public void TestCompilePatch__Edit() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig("ghi/jkl", new TestConfigNode("@NODE") + { + { "@bar", "bleh" }, + }), + Command.Edit, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + EditPatch patch = Assert.IsType(patchCompiler.CompilePatch(protoPatch)); + + Assert.Same(protoPatch.urlConfig, patch.UrlConfig); + AssertNodeMatcher(patch.NodeMatcher); + + ConfigNode config = new TestConfigNode("NODE") + { + { "name", "foo" }, + { "bar", "baz" }, + }; + + IProtoUrlConfig urlConfig = Substitute.For(); + urlConfig.Node.Returns(config); + urlConfig.UrlFile.Returns(file); + + LinkedList configs = new LinkedList(); + configs.AddLast(urlConfig); + + patch.Apply(configs, progress, logger); + + AssertNoErrors(); + + progress.Received().ApplyingUpdate(urlConfig, protoPatch.urlConfig); + + Assert.Single(configs); + Assert.NotSame(config, configs.First.Value.Node); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "name", "foo" }, + { "bar", "bleh" }, + }, configs.First.Value.Node); + Assert.Same(file, configs.First.Value.UrlFile); + } + + [Fact] + public void TestCompilePatch__Copy() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig("ghi/jkl", new TestConfigNode("+NODE") + { + { "@name", "boo" }, + { "@bar", "bleh" }, + }), + Command.Copy, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + CopyPatch patch = Assert.IsType(patchCompiler.CompilePatch(protoPatch)); + + Assert.Same(protoPatch.urlConfig, patch.UrlConfig); + AssertNodeMatcher(patch.NodeMatcher); + + ConfigNode config = new TestConfigNode("NODE") + { + { "name", "foo" }, + { "bar", "baz" }, + }; + + IProtoUrlConfig urlConfig = Substitute.For(); + urlConfig.Node.Returns(config); + urlConfig.UrlFile.Returns(file); + + LinkedList configs = new LinkedList(); + configs.AddLast(urlConfig); + + patch.Apply(configs, progress, logger); + + AssertNoErrors(); + + progress.Received().ApplyingCopy(urlConfig, protoPatch.urlConfig); + + IProtoUrlConfig[] newConfigs = configs.ToArray(); + + Assert.Equal(2, newConfigs.Length); + Assert.Same(config, newConfigs[0].Node); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "name", "foo" }, + { "bar", "baz" }, + }, newConfigs[0].Node); + AssertNodesEqual(new TestConfigNode("NODE") + { + { "name", "boo" }, + { "bar", "bleh" }, + }, newConfigs[1].Node); + Assert.Same(file, newConfigs[1].UrlFile); + } + + [Fact] + public void TestCompilePatch__Delete() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("-NODE")), + Command.Delete, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + DeletePatch patch = Assert.IsType(patchCompiler.CompilePatch(protoPatch)); + + Assert.Same(protoPatch.urlConfig, patch.UrlConfig); + AssertNodeMatcher(patch.NodeMatcher); + + IProtoUrlConfig urlConfig = Substitute.For(); + urlConfig.Node.Returns(new TestConfigNode("NODE") + { + { "name", "foo" }, + { "bar", "baz" }, + }); + + LinkedList configs = new LinkedList(); + configs.AddLast(urlConfig); + + patch.Apply(configs, progress, logger); + + AssertNoErrors(); + + progress.Received().ApplyingDelete(urlConfig, protoPatch.urlConfig); + + Assert.Empty(configs); + } + + [Fact] + public void TestCompilePatch__NullProtoPatch() + { + ArgumentNullException ex = Assert.Throws(delegate + { + patchCompiler.CompilePatch(null); + }); + + Assert.Equal("protoPatch", ex.ParamName); + } + + [Fact] + public void TestCompilePatch__InvalidCommand__Replace() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode()), + Command.Replace, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + ArgumentException ex = Assert.Throws(delegate + { + patchCompiler.CompilePatch(protoPatch); + }); + + Assert.Equal("protoPatch", ex.ParamName); + Assert.Contains("invalid command for a root node: Replace", ex.Message); + } + + [Fact] + public void TestCompilePatch__InvalidCommand__Create() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode()), + Command.Create, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + ArgumentException ex = Assert.Throws(delegate + { + patchCompiler.CompilePatch(protoPatch); + }); + + Assert.Equal("protoPatch", ex.ParamName); + Assert.Contains("invalid command for a root node: Create", ex.Message); + } + + [Fact] + public void TestCompilePatch__InvalidCommand__Rename() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode()), + Command.Rename, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + ArgumentException ex = Assert.Throws(delegate + { + patchCompiler.CompilePatch(protoPatch); + }); + + Assert.Equal("protoPatch", ex.ParamName); + Assert.Contains("invalid command for a root node: Rename", ex.Message); + } + + [Fact] + public void TestCompilePatch__InvalidCommand__Paste() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode()), + Command.Paste, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + ArgumentException ex = Assert.Throws(delegate + { + patchCompiler.CompilePatch(protoPatch); + }); + + Assert.Equal("protoPatch", ex.ParamName); + Assert.Contains("invalid command for a root node: Paste", ex.Message); + } + + [Fact] + public void TestCompilePatch__InvalidCommand__Special() + { + ProtoPatch protoPatch = new ProtoPatch( + UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode()), + Command.Special, + "NODE", + "foo", + null, + "#bar", + Substitute.For() + ); + + ArgumentException ex = Assert.Throws(delegate + { + patchCompiler.CompilePatch(protoPatch); + }); + + Assert.Equal("protoPatch", ex.ParamName); + Assert.Contains("invalid command for a root node: Special", ex.Message); + } + + private void AssertNodeMatcher(INodeMatcher matcher) + { + Assert.True(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "foo" }, + { "bar", "baz" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "foo" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "boo" }, + { "bar", "baz" }, + })); + + Assert.False(matcher.IsMatch(new ConfigNode("NODE"))); + + Assert.False(matcher.IsMatch(new TestConfigNode("NADE") + { + { "name", "foo" }, + { "bar", "baz" }, + })); + + Assert.False(matcher.IsMatch(new TestConfigNode("NODE") + { + { "name", "boo" }, + { "bar", "baz" }, + })); + } + + private void AssertNodesEqual(ConfigNode expected, ConfigNode actual) + { + Assert.Equal(expected.ToString(), actual.ToString()); + } + + private void AssertNoErrors() + { + progress.DidNotReceiveWithAnyArgs().Error(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + } +} diff --git a/ModuleManagerTests/Patches/ProtoPatchBuilderTest.cs b/ModuleManagerTests/Patches/ProtoPatchBuilderTest.cs new file mode 100644 index 00000000..fd2ff4ab --- /dev/null +++ b/ModuleManagerTests/Patches/ProtoPatchBuilderTest.cs @@ -0,0 +1,1373 @@ +using System; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Collections; +using ModuleManager.Patches; +using ModuleManager.Patches.PassSpecifiers; +using ModuleManager.Progress; +using ModuleManager.Tags; + +namespace ModuleManagerTests.Patches +{ + public class ProtoPatchBuilderTest + { + private readonly IPatchProgress progress; + private readonly ProtoPatchBuilder builder; + private readonly UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE")); + + public ProtoPatchBuilderTest() + { + progress = Substitute.For(); + builder = new ProtoPatchBuilder(progress); + } + + [Fact] + public void TestBuild__PrimaryValueNull() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__PrimaryValue() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", "stuff", null)); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Equal("stuff", protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Needs() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("NEEDS", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Equal("stuff", protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Needs__Case1() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("Needs", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Equal("stuff", protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Needs__Case2() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("needs", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Equal("stuff", protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Has() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("HAS", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Equal("stuff", protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Has__Case1() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("Has", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Equal("stuff", protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Has__Case2() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("has", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Equal("stuff", protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__First() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", null, null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__First__Case1() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("First", null, null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__First__Case2() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("first", null, null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Before() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("BEFORE", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + BeforePassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__Before__Case1() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("Before", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + BeforePassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__Before__Case2() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("before", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + BeforePassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__For() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FOR", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + ForPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__For__Case1() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("For", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + ForPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__For__Case2() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("for", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + ForPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__After() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("AFTER", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + AfterPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__After__Case1() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("After", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + AfterPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__After__Case2() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("after", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + AfterPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + Assert.Same(urlConfig, passSpecifier.urlConfig); + } + + [Fact] + public void TestBuild__Last() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("LAST", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + LastPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + } + + [Fact] + public void TestBuild__Last__Case1() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("Last", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + LastPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + } + + [Fact] + public void TestBuild__Last__Case2() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("last", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + LastPassSpecifier passSpecifier = Assert.IsType(protoPatch.passSpecifier); + Assert.Equal("stuff", passSpecifier.mod); + } + + [Fact] + public void TestBuild__Final() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FINAL", null, null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Final__Case1() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("Final", null, null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Final__Case2() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("final", null, null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__Insert__InsertPass() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("NEEDS", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Insert, tagList); + + EnsureNoErrors(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Insert, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Equal("stuff", protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__UrlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + builder.Build(null, Command.Edit, Substitute.For()); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestBuild__TagListNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + builder.Build(urlConfig, Command.Edit, null); + }); + + Assert.Equal("tagList", ex.ParamName); + } + + [Fact] + public void TestBuild__PrimaryValueEmpty() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", "", null)); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "empty brackets detected on patch name: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__NodeNameOnInsert() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", "blah", null)); + + Assert.Null(builder.Build(urlConfig, Command.Insert, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "name specifier detected on insert node (not a patch): abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__TrailerOnPrimaryTag() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", "stuff", "otherStuff")); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "unrecognized trailer: 'otherStuff' on: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Equal("stuff", protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__TrailerOnSomeTag() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("NEEDS", "stuff", "morestuff") + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "unrecognized trailer: 'morestuff' on: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Equal("stuff", protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__MoreThanOneNeeds() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("NEEDS", "stuff", null), + new Tag("NEEDS", "otherStuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "more than one :NEEDS tag detected, ignoring all but the first: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Equal("stuff", protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__NullNeeds() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("NEEDS", null, null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :NEEDS tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__EmptyNeeds() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("NEEDS", "", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :NEEDS tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__MoreThanOneHas() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("HAS", "stuff", null), + new Tag("HAS", "otherStuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "more than one :HAS tag detected, ignoring all but the first: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Equal("stuff", protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__NullHas() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("HAS", null, null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :HAS tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__EmptyHas() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("HAS", "", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :HAS tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__HasOnInsert() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("HAS", "", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Insert, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, ":HAS detected on insert node (not a patch): abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__BracketsOnFirst() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", "", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "value detected on :FIRST tag: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__ValueOnFirst() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "value detected on :FIRST tag: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__MoreThanOnePass__First() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FINAL", null, null), + new Tag("FIRST", null, null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__PassSpecifierOnInsert__First() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", null, null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Insert, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "pass specifier detected on insert node (not a patch): abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__NullBefore() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("BEFORE", null, null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :BEFORE tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__EmptyBefore() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("BEFORE", "", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :BEFORE tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__MoreThanOnePass__Before() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", null, null), + new Tag("BEFORE", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__PassSpecifierOnInsert__Before() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("BEFORE", "mod1", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Insert, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "pass specifier detected on insert node (not a patch): abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__NullFor() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FOR", null, null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :FOR tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__EmptyFor() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FOR", "", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :FOR tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__MoreThanOnePass__For() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", null, null), + new Tag("FOR", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__PassSpecifierOnInsert__For() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FOR", "mod1", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Insert, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "pass specifier detected on insert node (not a patch): abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__NullAfter() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("AFTER", null, null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :AFTER tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__EmptyAfter() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("AFTER", "", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :AFTER tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__MoreThanOnePass__After() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", null, null), + new Tag("AFTER", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__PassSpecifierOnInsert__After() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("AFTER", "mod1", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Insert, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "pass specifier detected on insert node (not a patch): abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__NullLast() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("LAST", null, null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :LAST tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__EmptyLast() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("LAST", "", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Copy, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "empty :LAST tag detected: abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__MoreThanOnePass__Last() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", null, null), + new Tag("LAST", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__PassSpecifierOnInsert__Last() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("LAST", "mod1", null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Insert, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "pass specifier detected on insert node (not a patch): abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__BracketsOnFinal() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FINAL", "", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "value detected on :FINAL tag: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__ValueOnFinal() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FINAL", "stuff", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "value detected on :FINAL tag: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__MoreThanOnePass__Final() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FIRST", null, null), + new Tag("FINAL", null, null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + [Fact] + public void TestBuild__PassSpecifierOnInsert__Final() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("FINAL", null, null) + )); + + Assert.Null(builder.Build(urlConfig, Command.Insert, tagList)); + + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.Received().Error(urlConfig, "pass specifier detected on insert node (not a patch): abc/def/NODE"); + EnsureNoExceptions(); + } + + [Fact] + public void TestBuild__UnrecognizedTag() + { + ITagList tagList = Substitute.For(); + tagList.PrimaryTag.Returns(new Tag("NODE", null, null)); + tagList.GetEnumerator().Returns(new ArrayEnumerator( + new Tag("SOMESTUFF", "blah", null) + )); + + ProtoPatch protoPatch = builder.Build(urlConfig, Command.Copy, tagList); + + progress.Received().Warning(urlConfig, "unrecognized tag: 'SOMESTUFF' on: abc/def/NODE"); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + + Assert.Same(urlConfig, protoPatch.urlConfig); + Assert.Equal(Command.Copy, protoPatch.command); + Assert.Equal("NODE", protoPatch.nodeType); + Assert.Null(protoPatch.nodeName); + Assert.Null(protoPatch.needs); + Assert.Null(protoPatch.has); + Assert.IsType(protoPatch.passSpecifier); + } + + private void EnsureNoErrors() + { + progress.DidNotReceiveWithAnyArgs().Warning(null, null); + progress.DidNotReceiveWithAnyArgs().Error(null, null); + EnsureNoExceptions(); + } + + private void EnsureNoExceptions() + { + progress.DidNotReceiveWithAnyArgs().Exception(null, null); + progress.DidNotReceiveWithAnyArgs().Exception(null, null, null); + } + } +} diff --git a/ModuleManagerTests/Progress/PatchProgressTest.cs b/ModuleManagerTests/Progress/PatchProgressTest.cs new file mode 100644 index 00000000..c78964e3 --- /dev/null +++ b/ModuleManagerTests/Progress/PatchProgressTest.cs @@ -0,0 +1,377 @@ +using System; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager; +using ModuleManager.Logging; +using ModuleManager.Progress; + +namespace ModuleManagerTests +{ + public class PatchProgressTest + { + private readonly IBasicLogger logger = Substitute.For(); + private readonly PatchProgress progress; + + public PatchProgressTest() + { + progress = new PatchProgress(logger); + } + + [Fact] + public void Test__Constructor__Nested() + { + IBasicLogger logger2 = Substitute.For(); + PatchProgress progress2 = new PatchProgress(progress, logger2); + + Assert.Same(progress.Counter, progress2.Counter); + + Assert.Equal(0, progress.Counter.patchedNodes); + + IProtoUrlConfig original = Substitute.For(); + original.FullUrl.Returns("abc/def.cfg/SOME_NODE"); + UrlDir.UrlConfig patch1 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("@SOME_NODE")); + + progress2.ApplyingUpdate(original, patch1); + Assert.Equal(1, progress.Counter.patchedNodes); + logger.AssertNoLog(); + logger2.AssertInfo("Applying update ghi/jkl/@SOME_NODE to abc/def.cfg/SOME_NODE"); + } + + [Fact] + public void TestPatchAdded() + { + Assert.Equal(0, progress.Counter.totalPatches); + progress.PatchAdded(); + Assert.Equal(1, progress.Counter.totalPatches); + progress.PatchAdded(); + Assert.Equal(2, progress.Counter.totalPatches); + } + + [Fact] + public void TestApplyingUpdate() + { + IProtoUrlConfig original = Substitute.For(); + original.FullUrl.Returns("abc/def.cfg/SOME_NODE"); + UrlDir.UrlConfig patch1 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("@SOME_NODE")); + UrlDir.UrlConfig patch2 = UrlBuilder.CreateConfig("pqr/stu", new ConfigNode("@SOME_NODE")); + + Assert.Equal(0, progress.Counter.patchedNodes); + + progress.ApplyingUpdate(original, patch1); + Assert.Equal(1, progress.Counter.patchedNodes); + logger.AssertInfo("Applying update ghi/jkl/@SOME_NODE to abc/def.cfg/SOME_NODE"); + + progress.ApplyingUpdate(original, patch2); + Assert.Equal(2, progress.Counter.patchedNodes); + logger.AssertInfo("Applying update pqr/stu/@SOME_NODE to abc/def.cfg/SOME_NODE"); + } + + [Fact] + public void TesApplyingCopy() + { + IProtoUrlConfig original = Substitute.For(); + original.FullUrl.Returns("abc/def.cfg/SOME_NODE"); + UrlDir.UrlConfig patch1 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("+SOME_NODE")); + UrlDir.UrlConfig patch2 = UrlBuilder.CreateConfig("pqr/stu", new ConfigNode("+SOME_NODE")); + + Assert.Equal(0, progress.Counter.patchedNodes); + + progress.ApplyingCopy(original, patch1); + Assert.Equal(1, progress.Counter.patchedNodes); + logger.AssertInfo("Applying copy ghi/jkl/+SOME_NODE to abc/def.cfg/SOME_NODE"); + + progress.ApplyingCopy(original, patch2); + Assert.Equal(2, progress.Counter.patchedNodes); + logger.AssertInfo("Applying copy pqr/stu/+SOME_NODE to abc/def.cfg/SOME_NODE"); + } + + [Fact] + public void TesApplyingDelete() + { + IProtoUrlConfig original = Substitute.For(); + original.FullUrl.Returns("abc/def.cfg/SOME_NODE"); + UrlDir.UrlConfig patch1 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("!SOME_NODE")); + UrlDir.UrlConfig patch2 = UrlBuilder.CreateConfig("pqr/stu", new ConfigNode("!SOME_NODE")); + + Assert.Equal(0, progress.Counter.patchedNodes); + + progress.ApplyingDelete(original, patch1); + Assert.Equal(1, progress.Counter.patchedNodes); + logger.AssertInfo("Applying delete ghi/jkl/!SOME_NODE to abc/def.cfg/SOME_NODE"); + + progress.ApplyingDelete(original, patch2); + Assert.Equal(2, progress.Counter.patchedNodes); + logger.AssertInfo("Applying delete pqr/stu/!SOME_NODE to abc/def.cfg/SOME_NODE"); + } + + [Fact] + public void TestPatchApplied() + { + int eventCounter = 0; + progress.OnPatchApplied.Add(() => eventCounter++); + Assert.Equal(0, progress.Counter.appliedPatches); + progress.PatchApplied(); + Assert.Equal(1, progress.Counter.appliedPatches); + Assert.Equal(1, eventCounter); + progress.PatchApplied(); + Assert.Equal(2, progress.Counter.appliedPatches); + Assert.Equal(2, eventCounter); + } + + [Fact] + public void TestNeedsUnsatisfiedRoot() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("SOME_OTHER_NODE")); + + Assert.Equal(0, progress.Counter.needsUnsatisfied); + + progress.NeedsUnsatisfiedRoot(config1); + Assert.Equal(1, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting root node in file abc/def node: SOME_NODE as it can't satisfy its NEEDS"); + + progress.NeedsUnsatisfiedRoot(config2); + Assert.Equal(2, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting root node in file ghi/jkl node: SOME_OTHER_NODE as it can't satisfy its NEEDS"); + } + + [Fact] + public void TestNeedsUnsatisfiedNode() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("SOME_OTHER_NODE")); + + Assert.Equal(0, progress.Counter.needsUnsatisfied); + + progress.NeedsUnsatisfiedNode(config1, "SOME/NODE/PATH/SOME_CHILD_NODE"); + Assert.Equal(0, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting node in file abc/def subnode: SOME/NODE/PATH/SOME_CHILD_NODE as it can't satisfy its NEEDS"); + + progress.NeedsUnsatisfiedNode(config2, "SOME/NODE/PATH/SOME_OTHER_CHILD_NODE"); + Assert.Equal(0, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting node in file ghi/jkl subnode: SOME/NODE/PATH/SOME_OTHER_CHILD_NODE as it can't satisfy its NEEDS"); + } + + [Fact] + public void TestNeedsUnsatisfiedValue() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("SOME_OTHER_NODE")); + + Assert.Equal(0, progress.Counter.needsUnsatisfied); + + progress.NeedsUnsatisfiedValue(config1, "SOME/NODE/PATH/some_value"); + Assert.Equal(0, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting value in file abc/def value: SOME/NODE/PATH/some_value as it can't satisfy its NEEDS"); + + progress.NeedsUnsatisfiedValue(config2, "SOME/NODE/PATH/some_other_value"); + Assert.Equal(0, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting value in file ghi/jkl value: SOME/NODE/PATH/some_other_value as it can't satisfy its NEEDS"); + } + + [Fact] + public void TestNeedsUnsatisfiedBefore() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("SOME_OTHER_NODE")); + + Assert.Equal(0, progress.Counter.needsUnsatisfied); + + progress.NeedsUnsatisfiedBefore(config1); + Assert.Equal(1, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting root node in file abc/def node: SOME_NODE as it can't satisfy its BEFORE"); + + progress.NeedsUnsatisfiedBefore(config2); + Assert.Equal(2, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting root node in file ghi/jkl node: SOME_OTHER_NODE as it can't satisfy its BEFORE"); + } + + [Fact] + public void TestNeedsUnsatisfiedFor() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("SOME_OTHER_NODE")); + + Assert.Equal(0, progress.Counter.needsUnsatisfied); + + progress.NeedsUnsatisfiedFor(config1); + Assert.Equal(1, progress.Counter.needsUnsatisfied); + logger.AssertWarning("Deleting root node in file abc/def node: SOME_NODE as it can't satisfy its FOR (this shouldn't happen)"); + + progress.NeedsUnsatisfiedFor(config2); + Assert.Equal(2, progress.Counter.needsUnsatisfied); + logger.AssertWarning("Deleting root node in file ghi/jkl node: SOME_OTHER_NODE as it can't satisfy its FOR (this shouldn't happen)"); + } + + [Fact] + public void TestNeedsUnsatisfiedAfter() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("ghi/jkl", new ConfigNode("SOME_OTHER_NODE")); + + Assert.Equal(0, progress.Counter.needsUnsatisfied); + + progress.NeedsUnsatisfiedAfter(config1); + Assert.Equal(1, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting root node in file abc/def node: SOME_NODE as it can't satisfy its AFTER"); + + progress.NeedsUnsatisfiedAfter(config2); + Assert.Equal(2, progress.Counter.needsUnsatisfied); + logger.AssertInfo("Deleting root node in file ghi/jkl node: SOME_OTHER_NODE as it can't satisfy its AFTER"); + } + + [Fact] + public void TestStartingPass() + { + EventData.OnEvent onEvent = Substitute.For.OnEvent>(); + progress.OnPassStarted.Add(onEvent); + IPass pass1 = Substitute.For(); + pass1.Name.Returns(":SOME_PASS"); + + progress.PassStarted(pass1); + + logger.AssertInfo(":SOME_PASS pass"); + onEvent.Received()(pass1); + } + + [Fact] + public void TestStartingPass__NullArgument() + { + EventData.OnEvent onEvent = Substitute.For.OnEvent>(); + progress.OnPassStarted.Add(onEvent); + + ArgumentNullException ex = Assert.Throws(delegate + { + progress.PassStarted(null); + }); + + Assert.Equal("pass", ex.ParamName); + + logger.AssertNoLog(); + onEvent.DidNotReceiveWithAnyArgs()(null); + } + + [Fact] + public void TestWarning() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_OTHER_NODE")); + + Assert.Equal(0, progress.Counter.warnings); + + progress.Warning(config1, "I'm warning you"); + Assert.Equal(1, progress.Counter.warnings); + Assert.Equal(1, progress.Counter.warningFiles["abc/def.cfg"]); + logger.AssertWarning("I'm warning you"); + + progress.Warning(config2, "You should probably pay attention to this"); + Assert.Equal(2, progress.Counter.warnings); + Assert.Equal(2, progress.Counter.warningFiles["abc/def.cfg"]); + logger.AssertWarning("You should probably pay attention to this"); + } + + [Fact] + public void TestError() + { + Assert.Equal(0, progress.Counter.errors); + + progress.Error("An error message no one is going to read"); + Assert.Equal(1, progress.Counter.errors); + + progress.Error("Maybe someone will read this one"); + Assert.Equal(2, progress.Counter.errors); + } + + [Fact] + public void TestError__Config() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_OTHER_NODE")); + + Assert.Equal(0, progress.Counter.errors); + Assert.False(progress.Counter.errorFiles.ContainsKey("abc/def.cfg")); + + progress.Error(config1, "An error message no one is going to read"); + Assert.Equal(1, progress.Counter.errors); + Assert.Equal(1, progress.Counter.errorFiles["abc/def.cfg"]); + logger.AssertError("An error message no one is going to read"); + + progress.Error(config2, "Maybe someone will read this one"); + Assert.Equal(2, progress.Counter.errors); + Assert.Equal(2, progress.Counter.errorFiles["abc/def.cfg"]); + logger.AssertError("Maybe someone will read this one"); + } + + [Fact] + public void TestException() + { + Exception e1 = new Exception(); + Exception e2 = new Exception(); + + Assert.Equal(0, progress.Counter.exceptions); + + progress.Exception("An exception was thrown", e1); + Assert.Equal(1, progress.Counter.exceptions); + logger.AssertException("An exception was thrown", e1); + + progress.Exception("An exception was tossed", e2); + Assert.Equal(2, progress.Counter.exceptions); + logger.AssertException("An exception was tossed", e2); + } + + [Fact] + public void TestException__Url() + { + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_NODE")); + Exception e1 = new Exception(); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("abc/def", new ConfigNode("SOME_OTHER_NODE")); + Exception e2 = new Exception(); + + Assert.Equal(0, progress.Counter.exceptions); + Assert.False(progress.Counter.errorFiles.ContainsKey("abc/def.cfg")); + + progress.Exception(config1, "An exception was thrown", e1); + Assert.Equal(1, progress.Counter.exceptions); + Assert.Equal(1, progress.Counter.errorFiles["abc/def.cfg"]); + logger.AssertException("An exception was thrown", e1); + + progress.Exception(config2, "An exception was tossed", e2); + Assert.Equal(2, progress.Counter.exceptions); + Assert.Equal(2, progress.Counter.errorFiles["abc/def.cfg"]); + logger.AssertException("An exception was tossed", e2); + } + + [Fact] + public void TestProgressFraction() + { + Assert.Equal(0, progress.ProgressFraction); + + progress.Counter.needsUnsatisfied.Increment(); + progress.Counter.needsUnsatisfied.Increment(); + + progress.Counter.totalPatches.Increment(); + progress.Counter.totalPatches.Increment(); + progress.Counter.totalPatches.Increment(); + progress.Counter.totalPatches.Increment(); + + Assert.Equal(0, progress.ProgressFraction); + + progress.Counter.appliedPatches.Increment(); + + Assert.Equal(0.25, progress.ProgressFraction); + + progress.Counter.appliedPatches.Increment(); + + Assert.Equal(0.5, progress.ProgressFraction); + + progress.Counter.appliedPatches.Increment(); + + Assert.Equal(0.75, progress.ProgressFraction); + + progress.Counter.appliedPatches.Increment(); + + Assert.Equal(1, progress.ProgressFraction); + } + } +} diff --git a/ModuleManagerTests/Properties/AssemblyInfo.cs b/ModuleManagerTests/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..fd57fdd5 --- /dev/null +++ b/ModuleManagerTests/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ModuleManagerTests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ModuleManagerTests")] +[assembly: AssemblyCopyright("Copyright © 2017")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("bc2a08c8-64ef-4823-a40b-8889c1ccfd75")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/ModuleManagerTests/ProtoUrlConfigTest.cs b/ModuleManagerTests/ProtoUrlConfigTest.cs new file mode 100644 index 00000000..f16cd1bd --- /dev/null +++ b/ModuleManagerTests/ProtoUrlConfigTest.cs @@ -0,0 +1,87 @@ +using System; +using Xunit; +using TestUtils; +using ModuleManager; + +namespace ModuleManagerTests +{ + public class ProtoUrlConfigTest + { + [Fact] + public void TestContructor__UrlFileNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new ProtoUrlConfig(null, new ConfigNode()); + }); + + Assert.Equal("urlFile", ex.ParamName); + } + + [Fact] + public void TestContructor__NodeNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new ProtoUrlConfig(UrlBuilder.CreateFile("foo/bar"), null); + }); + + Assert.Equal("node", ex.ParamName); + } + + [Fact] + public void TestUrlFile() + { + UrlDir.UrlFile urlFile = UrlBuilder.CreateFile("abc/def.cfg"); + ProtoUrlConfig protoUrlConfig = new ProtoUrlConfig(urlFile, new ConfigNode()); + + Assert.Same(urlFile, protoUrlConfig.UrlFile); + } + + [Fact] + public void TestNode() + { + ConfigNode node = new ConfigNode("NODE"); + ProtoUrlConfig protoUrlConfig = new ProtoUrlConfig(UrlBuilder.CreateFile("foo/bar"), node); + + Assert.Same(node, protoUrlConfig.Node); + } + + [Fact] + public void TestFileUrl() + { + ProtoUrlConfig protoUrlConfig = new ProtoUrlConfig(UrlBuilder.CreateFile("abc/def.cfg"), new ConfigNode()); + + Assert.Equal("abc/def.cfg", protoUrlConfig.FileUrl); + } + + [Fact] + public void TestNodeType() + { + ProtoUrlConfig protoUrlConfig = new ProtoUrlConfig(UrlBuilder.CreateFile("abc/def"), new ConfigNode("SOME_NODE")); + + Assert.Equal("SOME_NODE", protoUrlConfig.NodeType); + } + + [Fact] + public void TestFullUrl() + { + ProtoUrlConfig protoUrlConfig = new ProtoUrlConfig(UrlBuilder.CreateFile("abc/def.cfg"), new ConfigNode("SOME_NODE")); + + Assert.Equal("abc/def.cfg/SOME_NODE", protoUrlConfig.FullUrl); + } + + [Fact] + public void TestFullUrl__NameValue() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "name", "some_value" }, + }; + + ProtoUrlConfig protoUrlConfig = new ProtoUrlConfig(UrlBuilder.CreateFile("abc/def.cfg"), node); + + Assert.Equal("abc/def.cfg/SOME_NODE[some_value]", protoUrlConfig.FullUrl); + } + } +} diff --git a/ModuleManagerTests/Tags/TagListParserTest.cs b/ModuleManagerTests/Tags/TagListParserTest.cs new file mode 100644 index 00000000..9ee395d0 --- /dev/null +++ b/ModuleManagerTests/Tags/TagListParserTest.cs @@ -0,0 +1,290 @@ +using System; +using Xunit; +using NSubstitute; +using TestUtils; +using ModuleManager.Progress; +using ModuleManager.Tags; + +namespace ModuleManagerTests.Tags +{ + public class TagListParserTest + { + private readonly IPatchProgress progress = Substitute.For(); + private readonly TagListParser tagListParser; + private readonly UrlDir.UrlConfig urlConfig = UrlBuilder.CreateConfig("abc/def.cfg", new ConfigNode("BLAH")); + + public TagListParserTest() + { + tagListParser = new TagListParser(progress); + } + + [Fact] + public void TestConstructor__ProgressNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new TagListParser(null); + }); + + Assert.Equal("progress", ex.ParamName); + } + + [Fact] + public void TestParse__OnlyPrimaryKey() + { + ITagList tagList = tagListParser.Parse("01", urlConfig); + Assert.Equal(new Tag("01", null, null), tagList.PrimaryTag); + Assert.Empty(tagList); + } + + [Fact] + public void TestParse__OnlyPrimaryKeyAndValue() + { + ITagList tagList = tagListParser.Parse("01[02]", urlConfig); + Assert.Equal(new Tag("01", "02", null), tagList.PrimaryTag); + Assert.Empty(tagList); + } + + [Fact] + public void TestParse__OnlyPrimaryKeyValueAndTrailer() + { + ITagList tagList = tagListParser.Parse("01[02]03", urlConfig); + Assert.Equal(new Tag("01", "02", "03"), tagList.PrimaryTag); + Assert.Empty(tagList); + } + + [Fact] + public void TestParse__OnlyPrimaryKeyValueAndTrailer__ValueHasSomeStuff() + { + ITagList tagList = tagListParser.Parse("01[02:[03:04[05]]]06", urlConfig); + Assert.Equal(new Tag("01", "02:[03:04[05]]", "06"), tagList.PrimaryTag); + Assert.Empty(tagList); + } + + [Fact] + public void TestParse__TagWithOnlyKey() + { + ITagList tagList = tagListParser.Parse("01[02]03:04:05", urlConfig); + Assert.Equal(new Tag("01", "02", "03"), tagList.PrimaryTag); + Assert.Equal(new[] { + new Tag("04", null, null), + new Tag("05", null, null), + }, tagList); + } + + [Fact] + public void TestParse__TagWithOnlyKeyAndValue() + { + ITagList tagList = tagListParser.Parse("01[02]03:04[05]:06[07]", urlConfig); + Assert.Equal(new Tag("01", "02", "03"), tagList.PrimaryTag); + Assert.Equal(new[] { + new Tag("04", "05", null), + new Tag("06", "07", null), + }, tagList); + } + + [Fact] + public void TestParse__FullTags() + { + ITagList tagList = tagListParser.Parse("01[02]03:04[05]06:07[08]09", urlConfig); + Assert.Equal(new Tag("01", "02", "03"), tagList.PrimaryTag); + Assert.Equal(new[] { + new Tag("04", "05", "06"), + new Tag("07", "08", "09"), + }, tagList); + } + + [Fact] + public void TestParse__MixedTags() + { + ITagList tagList = tagListParser.Parse("01[02]03:04:05[06]:07[08]09", urlConfig); + Assert.Equal(new Tag("01", "02", "03"), tagList.PrimaryTag); + Assert.Equal(new[] { + new Tag("04", null, null), + new Tag("05", "06", null), + new Tag("07", "08", "09"), + }, tagList); + } + + [Fact] + public void TestParse__StringNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + tagListParser.Parse(null, urlConfig); + }); + + Assert.Equal("toParse", ex.ParamName); + } + + [Fact] + public void TestParse__UrlConfigNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + tagListParser.Parse("BLAH", null); + }); + + Assert.Equal("urlConfig", ex.ParamName); + } + + [Fact] + public void TestParse__Empty() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("", urlConfig); + }); + + Assert.Equal("can't create tag list from empty string", ex.Message); + } + + [Fact] + public void TestParse__StartsWithOpenBracket() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("[stuff]", urlConfig); + }); + + Assert.Equal("can't create tag list beginning with [", ex.Message); + } + + [Fact] + public void TestParse__StartsWithColon() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse(":stuff", urlConfig); + }); + + Assert.Equal("can't create tag list beginning with :", ex.Message); + } + + [Fact] + public void TestParse__EndsWithColon() + { + ITagList tagList = tagListParser.Parse("stuff:blah::", urlConfig); + + progress.Received().Warning(urlConfig, "trailing : detected"); + + Assert.Equal(new Tag("stuff", null, null), tagList.PrimaryTag); + Assert.Equal(new[] { + new Tag("blah", null, null), + }, tagList); + } + + [Fact] + public void TestParse__ClosingBracketInPrimaryKey() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc]def", urlConfig); + }); + + Assert.Equal("encountered closing bracket in primary key", ex.Message); + } + + [Fact] + public void TestParse__PrimaryValueHasNoClosingBracket() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc[def[ghi]jkl", urlConfig); + }); + + Assert.Equal("reached end of the tag list without encountering a close bracket", ex.Message); + } + + [Fact] + public void TestParse__OpeningBracketInPrimaryTrailer() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc[def]ghi[jkl]", urlConfig); + }); + + Assert.Equal("encountered opening bracket in primary trailer", ex.Message); + } + + [Fact] + public void TestParse__ClosingBracketInPrimaryTrailer() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc[def]ghi]jkl", urlConfig); + }); + + Assert.Equal("encountered closing bracket in primary trailer", ex.Message); + } + + [Fact] + public void TestParse__TagStartsWithOpenBracket() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc:def:[ghi]", urlConfig); + }); + + Assert.Equal("tag can't start with [", ex.Message); + } + + [Fact] + public void TestParse__TagStartsWithColon() + { + ITagList tagList = tagListParser.Parse("abc:def::ghi", urlConfig); + + progress.Received().Warning(urlConfig, "extra : detected"); + + Assert.Equal(new Tag("abc", null, null), tagList.PrimaryTag); + Assert.Equal(new[] { + new Tag("def", null, null), + new Tag("ghi", null, null), + }, tagList); + } + + [Fact] + public void TestParse__ClosingBracketInKey() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc:def:ghi]jkl", urlConfig); + }); + + Assert.Equal("encountered closing bracket in key", ex.Message); + } + + [Fact] + public void TestParse__ValueHasNoClosingBracket() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc:def:ghi[jkl[mno]pqr", urlConfig); + }); + + Assert.Equal("reached end of the tag list without encountering a close bracket", ex.Message); + } + + [Fact] + public void TestParse__OpeningBracketInTrailer() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc:def:ghi[jkl]mno[pqr]", urlConfig); + }); + + Assert.Equal("encountered opening bracket in trailer", ex.Message); + } + + [Fact] + public void TestParse__ClosingBracketInTrailer() + { + FormatException ex = Assert.Throws(delegate + { + tagListParser.Parse("abc:def:ghi[jkl]mno]pqr", urlConfig); + }); + + Assert.Equal("encountered closing bracket in trailer", ex.Message); + } + } +} diff --git a/ModuleManagerTests/Tags/TagListTest.cs b/ModuleManagerTests/Tags/TagListTest.cs new file mode 100644 index 00000000..0d3d40dd --- /dev/null +++ b/ModuleManagerTests/Tags/TagListTest.cs @@ -0,0 +1,44 @@ +using System; +using Xunit; +using ModuleManager.Tags; + +namespace ModuleManagerTests.Tags +{ + public class TagListTest + { + [Fact] + public void TestPrimaryTag() + { + Tag primaryTag = new Tag("stuff", null, null); + TagList tagList = new TagList(primaryTag, new Tag[0]); + + Assert.Equal(primaryTag, tagList.PrimaryTag); + } + + [Fact] + public void TestEnumeration() + { + Tag primaryTag = new Tag("stuff", null, null); + Tag tag1 = new Tag("tag1", null, null); + Tag tag2 = new Tag("tag2", null, null); + + Tag[] tags = new Tag[] { tag1, tag2 }; + TagList tagList = new TagList(primaryTag, tags); + + tags[0] = new Tag("tag3", null, null); + + Assert.Equal(new[] { tag1, tag2 }, tagList); + } + + [Fact] + public void TestConstructor__TagsNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new TagList(new Tag("blah", null, null), null); + }); + + Assert.Equal("tags", ex.ParamName); + } + } +} diff --git a/ModuleManagerTests/Tags/TagTest.cs b/ModuleManagerTests/Tags/TagTest.cs new file mode 100644 index 00000000..fec92b91 --- /dev/null +++ b/ModuleManagerTests/Tags/TagTest.cs @@ -0,0 +1,145 @@ +using System; +using Xunit; +using ModuleManager.Tags; + +namespace ModuleManagerTests.Tags +{ + public class TagTest + { + [Fact] + public void Test__OnlyKey() + { + Tag tag = new Tag("key", null, null); + + Assert.Equal("key", tag.key); + Assert.Null(tag.value); + Assert.Null(tag.trailer); + } + + [Fact] + public void Test__KeyAndValue() + { + Tag tag = new Tag("key", "value", null); + + Assert.Equal("key", tag.key); + Assert.Equal("value", tag.value); + Assert.Null(tag.trailer); + } + + [Fact] + public void Test__KeyAndEmptyValue() + { + Tag tag = new Tag("key", "", null); + + Assert.Equal("key", tag.key); + Assert.Equal("", tag.value); + Assert.Null(tag.trailer); + } + + [Fact] + public void Test__KeyValueAndTrailer() + { + Tag tag = new Tag("key", "value", "trailer"); + + Assert.Equal("key", tag.key); + Assert.Equal("value", tag.value); + Assert.Equal("trailer", tag.trailer); + } + + [Fact] + public void Test__KeyEmptyValueAndTrailer() + { + Tag tag = new Tag("key", "", "trailer"); + + Assert.Equal("key", tag.key); + Assert.Equal("", tag.value); + Assert.Equal("trailer", tag.trailer); + } + + [Fact] + public void TestConstructor__KeyNull() + { + ArgumentNullException ex = Assert.Throws(delegate + { + new Tag(null, "value", "trailer"); + }); + + Assert.Equal("key", ex.ParamName); + } + + [Fact] + public void TestConstructor__KeyEmpty() + { + ArgumentException ex = Assert.Throws(delegate + { + new Tag("", "value", "trailer"); + }); + + Assert.Equal("key", ex.ParamName); + Assert.Contains("can't be empty", ex.Message); + } + + [Fact] + public void TestConstructor__ValueNullButTrailerNotNull() + { + ArgumentException ex = Assert.Throws(delegate + { + new Tag("key", null, "trailer"); + }); + + Assert.Contains("trailer must be null if value is null", ex.Message); + } + + [Fact] + public void TestConstructor__TrailerEmpty() + { + ArgumentException ex = Assert.Throws(delegate + { + new Tag("key", "value", ""); + }); + + Assert.Equal("trailer", ex.ParamName); + Assert.Contains("can't be empty (null allowed)", ex.Message); + } + + [Fact] + public void TestToString__Key() + { + Tag tag = new Tag("key", null, null); + + Assert.Equal("< 'key' >", tag.ToString()); + } + + [Fact] + public void TestToString__KeyAndValue() + { + Tag tag = new Tag("key", "value", null); + + Assert.Equal("< 'key' [ 'value' ] >", tag.ToString()); + } + + [Fact] + public void TestToString__KeyAndEmptyValue() + { + Tag tag = new Tag("key", "", null); + + Assert.Equal("< 'key' [ '' ] >", tag.ToString()); + } + + [Fact] + public void TestToString__KeyValueAndTrailer() + { + Tag tag = new Tag("key", "value", "trailer"); + + Assert.Equal("< 'key' [ 'value' ] 'trailer' >", tag.ToString()); + } + + [Fact] + public void TestToString__KeyEmptyValueAndTrailer() + { + Tag tag = new Tag("key", "", "trailer"); + + Assert.Equal("< 'key' [ '' ] 'trailer' >", tag.ToString()); + } + } +} diff --git a/ModuleManagerTests/Threading/BackgroundTaskTest.cs b/ModuleManagerTests/Threading/BackgroundTaskTest.cs new file mode 100644 index 00000000..c9ebc594 --- /dev/null +++ b/ModuleManagerTests/Threading/BackgroundTaskTest.cs @@ -0,0 +1,72 @@ +using System; +using Xunit; +using ModuleManager.Threading; + +namespace ModuleManagerTests.Threading +{ + public class BackgroundTaskTest + { + [Fact] + public void Test__Start() + { + bool finish = false; + void Run() + { + while (!finish) continue; + } + + ITaskStatus status = BackgroundTask.Start(Run); + + Assert.True(status.IsRunning); + Assert.False(status.IsFinished); + Assert.False(status.IsExitedWithError); + Assert.Null(status.Exception); + + finish = true; + + while (status.IsRunning) continue; + + Assert.False(status.IsRunning); + Assert.True(status.IsFinished); + Assert.False(status.IsExitedWithError); + Assert.Null(status.Exception); + } + + [Fact] + public void Test__Start__Exception() + { + bool finish = false; + Exception ex = new Exception(); + void Run() + { + while (!finish) continue; + throw ex; + } + + ITaskStatus status = BackgroundTask.Start(Run); + + Assert.True(status.IsRunning); + Assert.False(status.IsFinished); + Assert.False(status.IsExitedWithError); + Assert.Null(status.Exception); + + finish = true; + + while (status.IsRunning) continue; + + Assert.False(status.IsRunning); + Assert.False(status.IsFinished); + Assert.True(status.IsExitedWithError); + Assert.Same(ex, status.Exception); + } + + [Fact] + public void Test__Run__ArgumentNull() + { + Assert.Throws(delegate + { + BackgroundTask.Start(null); + }); + } + } +} diff --git a/ModuleManagerTests/Threading/TaskStatusTest.cs b/ModuleManagerTests/Threading/TaskStatusTest.cs new file mode 100644 index 00000000..a32983ff --- /dev/null +++ b/ModuleManagerTests/Threading/TaskStatusTest.cs @@ -0,0 +1,121 @@ +using System; +using Xunit; +using ModuleManager.Threading; + +namespace ModuleManagerTests.Threading +{ + public class TaskStatusTest + { + [Fact] + public void Test__Cosntructor() + { + TaskStatus status = new TaskStatus(); + + Assert.True(status.IsRunning); + Assert.False(status.IsFinished); + Assert.False(status.IsExitedWithError); + Assert.Null(status.Exception); + } + + [Fact] + public void TestFinished() + { + TaskStatus status = new TaskStatus(); + + status.Finished(); + + Assert.False(status.IsRunning); + Assert.True(status.IsFinished); + Assert.False(status.IsExitedWithError); + Assert.Null(status.Exception); + } + + [Fact] + public void TestError() + { + TaskStatus status = new TaskStatus(); + Exception ex = new Exception(); + + status.Error(ex); + + Assert.False(status.IsRunning); + Assert.False(status.IsFinished); + Assert.True(status.IsExitedWithError); + Assert.Same(ex, status.Exception); + } + + [Fact] + public void TestFinished__AlreadyFinished() + { + TaskStatus status = new TaskStatus(); + + status.Finished(); + + Assert.Throws(delegate + { + status.Finished(); + }); + + Assert.False(status.IsRunning); + Assert.True(status.IsFinished); + Assert.False(status.IsExitedWithError); + Assert.Null(status.Exception); + } + + [Fact] + public void TestFinished__AlreadyErrored() + { + TaskStatus status = new TaskStatus(); + Exception ex = new Exception(); + + status.Error(ex); + + Assert.Throws(delegate + { + status.Finished(); + }); + + Assert.False(status.IsRunning); + Assert.False(status.IsFinished); + Assert.True(status.IsExitedWithError); + Assert.Same(ex, status.Exception); + } + + [Fact] + public void TestError__AlreadyFinished() + { + TaskStatus status = new TaskStatus(); + + status.Finished(); + + Assert.Throws(delegate + { + status.Error(new Exception()); + }); + + Assert.False(status.IsRunning); + Assert.True(status.IsFinished); + Assert.False(status.IsExitedWithError); + Assert.Null(status.Exception); + } + + [Fact] + public void TestError__AlreadyErrored() + { + TaskStatus status = new TaskStatus(); + Exception ex = new Exception(); + + status.Error(ex); + + Assert.Throws(delegate + { + status.Error(new Exception()); + }); + + Assert.False(status.IsRunning); + Assert.False(status.IsFinished); + Assert.True(status.IsExitedWithError); + Assert.Same(ex, status.Exception); + } + } +} diff --git a/ModuleManagerTests/Utils/CounterTest.cs b/ModuleManagerTests/Utils/CounterTest.cs new file mode 100644 index 00000000..2004e36a --- /dev/null +++ b/ModuleManagerTests/Utils/CounterTest.cs @@ -0,0 +1,72 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Xunit; +using ModuleManager.Utils; + +namespace ModuleManagerTests.Utils +{ + public class CounterTest + { + [Fact] + public void Test__Constructor() + { + Counter counter = new Counter(); + + Assert.Equal(0, counter.Value); + } + + [Fact] + public void TestIncrement() + { + Counter counter = new Counter(); + + Assert.Equal(0, counter.Value); + + counter.Increment(); + + Assert.Equal(1, counter.Value); + + counter.Increment(); + + Assert.Equal(2, counter.Value); + } + + [Fact] + public void TestToString() + { + Counter counter = new Counter(); + + Assert.Equal("0", counter.ToString()); + + counter.Increment(); + + Assert.Equal("1", counter.ToString()); + + counter.Increment(); + + Assert.Equal("2", counter.ToString()); + } + + [Fact] + public void Test__CastAsInt() + { + Counter counter = new Counter(); + int i; + + i = counter; + Assert.Equal(0, i); + + counter.Increment(); + + i = counter; + Assert.Equal(1, i); + + counter.Increment(); + + i = counter; + Assert.Equal(2, i); + } + } +} diff --git a/ModuleManagerTests/app.config b/ModuleManagerTests/app.config new file mode 100644 index 00000000..fe205877 --- /dev/null +++ b/ModuleManagerTests/app.config @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ModuleManagerTests/packages.config b/ModuleManagerTests/packages.config new file mode 100644 index 00000000..b159434d --- /dev/null +++ b/ModuleManagerTests/packages.config @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Properties/cat b/Properties/cat deleted file mode 100644 index 0fb30459..00000000 Binary files a/Properties/cat and /dev/null differ diff --git a/TestUtils/Properties/AssemblyInfo.cs b/TestUtils/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..4ae86d72 --- /dev/null +++ b/TestUtils/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("TestUtils")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("TestUtils")] +[assembly: AssemblyCopyright("Copyright © 2017")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("20eaafe6-510d-4374-8d2f-6b52d0178e85")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/TestUtils/TestConfigNode.cs b/TestUtils/TestConfigNode.cs new file mode 100644 index 00000000..694fc55e --- /dev/null +++ b/TestUtils/TestConfigNode.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections; + +namespace TestUtils +{ + public class TestConfigNode : ConfigNode, IEnumerable + { + public TestConfigNode() : base() { } + public TestConfigNode(string name) : base(name) { } + + public void Add(string name, string value) => Add(new Value(name, value)); + public void Add(Value value) => values.Add(value); + public void Add(string name, ConfigNode node) => AddNode(name, node); + public void Add(ConfigNode node) => AddNode(node); + + public IEnumerator GetEnumerator() => throw new NotImplementedException(); + } +} diff --git a/TestUtils/TestUtils.csproj b/TestUtils/TestUtils.csproj new file mode 100644 index 00000000..5c53b27c --- /dev/null +++ b/TestUtils/TestUtils.csproj @@ -0,0 +1,54 @@ + + + + + Debug + AnyCPU + {20EAAFE6-510D-4374-8D2F-6B52D0178E85} + Library + Properties + TestUtils + TestUtils + v4.7.1 + 512 + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + false + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + false + + + 8.0 + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TestUtils/UrlBuilder.cs b/TestUtils/UrlBuilder.cs new file mode 100644 index 00000000..e8e60bd5 --- /dev/null +++ b/TestUtils/UrlBuilder.cs @@ -0,0 +1,191 @@ +using System; +using System.IO; +using System.Linq; +using System.Reflection; + +namespace TestUtils +{ + public static class UrlBuilder + { + private static readonly FieldInfo UrlDir__field__type; + private static readonly FieldInfo UrlDir__field__name; + private static readonly FieldInfo UrlDir__field__root; + private static readonly FieldInfo UrlDir__field__parent; + + private static readonly FieldInfo UrlFile__field__name; + private static readonly FieldInfo UrlFile__field__fileType; + private static readonly FieldInfo UrlFile__field__fileExtension; + + static UrlBuilder() + { + FieldInfo[] UrlDirFields = typeof(UrlDir).GetFields(BindingFlags.Instance | BindingFlags.NonPublic); + FieldInfo[] UrlDirFields__DirectoryType = UrlDirFields.Where(field => field.FieldType == typeof(UrlDir.DirectoryType)).ToArray(); + FieldInfo[] UrlDirFields__string = UrlDirFields.Where(field => field.FieldType == typeof(string)).ToArray(); + FieldInfo[] UrlDirFields__UrlDir = UrlDirFields.Where(field => field.FieldType == typeof(UrlDir)).ToArray(); + + UrlDir__field__type = UrlDirFields__DirectoryType[0]; + UrlDir__field__name = UrlDirFields__string[0]; + UrlDir__field__root = UrlDirFields__UrlDir[0]; + UrlDir__field__parent = UrlDirFields__UrlDir[1]; + + FieldInfo[] UrlFileFields = typeof(UrlDir.UrlFile).GetFields(BindingFlags.Instance | BindingFlags.NonPublic); + FieldInfo[] UrlFileFields__string = UrlFileFields.Where(field => field.FieldType == typeof(string)).ToArray(); + FieldInfo[] UrlFileFields__FileType = UrlFileFields.Where(field => field.FieldType == typeof(UrlDir.FileType)).ToArray(); + + UrlFile__field__name = UrlFileFields__string[0]; + UrlFile__field__fileExtension = UrlFileFields__string[2]; + UrlFile__field__fileType = UrlFileFields__FileType[0]; + } + + public static UrlDir CreateRoot() + { + return new UrlDir(new UrlDir.ConfigDirectory[0], new UrlDir.ConfigFileType[0]); + } + + public static UrlDir CreateDir(string url, UrlDir parent = null) + { + if (parent == null) + { + parent = CreateRoot(); + } + else + { + UrlDir existingDir = parent.GetDirectory(url); + if (existingDir != null) return existingDir; + } + + UrlDir current = parent; + + foreach(string name in url.Split('/')) + { + UrlDir dir = CreateRoot(); + UrlDir__field__name.SetValue(dir, name); + UrlDir__field__root.SetValue(dir, current.root); + UrlDir__field__parent.SetValue(dir, current); + + current.children.Add(dir); + current = dir; + } + + return current; + } + + public static UrlDir CreateGameData(UrlDir root = null) + { + if (root == null) + { + root = CreateRoot(); + } + else + { + UrlDir potentialGameData = root.children.FirstOrDefault(dir => dir.type == UrlDir.DirectoryType.GameData && dir.name == ""); + if (potentialGameData != null) return potentialGameData; + } + + UrlDir gameData = CreateRoot(); + UrlDir__field__name.SetValue(gameData, ""); + UrlDir__field__type.SetValue(gameData, UrlDir.DirectoryType.GameData); + UrlDir__field__root.SetValue(gameData, root); + UrlDir__field__parent.SetValue(gameData, root); + + root.children.Add(gameData); + + return gameData; + } + + public static UrlDir.UrlFile CreateFile(string path, UrlDir parent = null) + { + int sepIndex = path.LastIndexOf('/'); + string name = path; + + if (sepIndex != -1) + { + parent = CreateDir(path.Substring(0, sepIndex), parent); + name = path.Substring(sepIndex + 1); + } + else if (parent == null) + { + parent = CreateRoot(); + } + + string nameWithoutExtension = Path.GetFileNameWithoutExtension(name); + string extension = Path.GetExtension(name); + if (!string.IsNullOrEmpty(extension)) extension = extension.Substring(1); + + UrlDir.UrlFile existingFile = parent.files.FirstOrDefault(f => f.name == nameWithoutExtension && f.fileExtension == extension); + if (existingFile != null) return existingFile; + + bool cfg = false; + string newName = name; + + UrlDir.FileType fileType = UrlDir.FileType.Unknown; + + switch (extension) + { + case "dll": + fileType = UrlDir.FileType.Assembly; + break; + case "ksp": + fileType = UrlDir.FileType.AssetBundle; + break; + case "wav": + case "ogg": + fileType = UrlDir.FileType.Audio; + break; + case "cfg": + fileType = UrlDir.FileType.Config; + break; + case "dae": + case "mu": + fileType = UrlDir.FileType.Model; + break; + case "dds": + case "jpg": + case "jpeg": + case "mbm": + case "png": + case "tga": + case "truecolor": + fileType = UrlDir.FileType.Texture; + break; + } + + // KSP tries to load .cfg files so need to have special handling + if (extension == "cfg") + { + cfg = true; + newName = name + ".not_cfg"; + } + + UrlDir.UrlFile file = new UrlDir.UrlFile(parent, new FileInfo(newName)); + + UrlFile__field__fileType.SetValue(file, fileType); + + if (cfg) + { + UrlFile__field__name.SetValue(file, nameWithoutExtension); + UrlFile__field__fileExtension.SetValue(file, "cfg"); + } + + parent.files.Add(file); + + return file; + } + + public static UrlDir.UrlConfig CreateConfig(ConfigNode node, UrlDir.UrlFile parent) + { + UrlDir.UrlConfig config = new UrlDir.UrlConfig(parent, node); + parent.configs.Add(config); + return config; + } + + public static UrlDir.UrlConfig CreateConfig(string url, ConfigNode node, UrlDir parent = null) + { + if (Path.GetExtension(url) != ".cfg") url += ".cfg"; + + UrlDir.UrlFile file = CreateFile(url, parent); + + return CreateConfig(node, file); + } + } +} diff --git a/TestUtilsTests/DummyTest.cs b/TestUtilsTests/DummyTest.cs new file mode 100644 index 00000000..815d8fb6 --- /dev/null +++ b/TestUtilsTests/DummyTest.cs @@ -0,0 +1,14 @@ +using System; +using Xunit; + +namespace TestUtilsTests +{ + public class DummyTest + { + [Fact] + public void PassingTest() + { + Assert.True(true); + } + } +} diff --git a/TestUtilsTests/Properties/AssemblyInfo.cs b/TestUtilsTests/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..054a6d53 --- /dev/null +++ b/TestUtilsTests/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("TestUtilsTests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("TestUtilsTests")] +[assembly: AssemblyCopyright("Copyright © 2017")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("e695c11f-4217-4014-9b51-7232a654c205")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/TestUtilsTests/TestConfigNodeTest.cs b/TestUtilsTests/TestConfigNodeTest.cs new file mode 100644 index 00000000..e544da78 --- /dev/null +++ b/TestUtilsTests/TestConfigNodeTest.cs @@ -0,0 +1,75 @@ +using System; +using Xunit; +using TestUtils; + +namespace TestUtilsTests +{ + public class TestConfigNodeTest + { + [Fact] + public void TestTestConfigNode() + { + ConfigNode node = new TestConfigNode("NODE") + { + { "value1", "something" }, + { "value2", "something else" }, + { "multiple", "first" }, + { "multiple", "second" }, + new ConfigNode.Value("foo", "bar"), + { "weird_values", "some\r\n\tstuff" }, + { "NODE_1", new TestConfigNode + { + { "name", "something" }, + { "stuff", "something else" }, + } + }, + new TestConfigNode("MULTIPLE") + { + { "value3", "blah" }, + { "value4", "bleh" }, + }, + new TestConfigNode("MULTIPLE") + { + { "value3", "blih" }, + { "value4", "bloh" }, + }, + }; + + Assert.Equal(6, node.values.Count); + AssertValue("value1", "something", node.values[0]); + AssertValue("value2", "something else", node.values[1]); + AssertValue("multiple", "first", node.values[2]); + AssertValue("multiple", "second", node.values[3]); + AssertValue("foo", "bar", node.values[4]); + AssertValue("weird_values", "some\r\n\tstuff", node.values[5]); + + Assert.Equal(3, node.nodes.Count); + ConfigNode innerNode1 = node.GetNode("NODE_1"); + Assert.NotNull(innerNode1); + + Assert.Equal("NODE_1", node.nodes[0].name); + Assert.Equal(2, node.nodes[0].values.Count); + AssertValue("name", "something", node.nodes[0].values[0]); + AssertValue("stuff", "something else", node.nodes[0].values[1]); + Assert.Empty(node.nodes[0].nodes); + + Assert.Equal("MULTIPLE", node.nodes[1].name); + Assert.Equal(2, node.nodes[1].values.Count); + AssertValue("value3", "blah", node.nodes[1].values[0]); + AssertValue("value4", "bleh", node.nodes[1].values[1]); + Assert.Empty(node.nodes[1].nodes); + + Assert.Equal("MULTIPLE", node.nodes[2].name); + Assert.Equal(2, node.nodes[2].values.Count); + AssertValue("value3", "blih", node.nodes[2].values[0]); + AssertValue("value4", "bloh", node.nodes[2].values[1]); + Assert.Empty(node.nodes[2].nodes); + } + + private void AssertValue(string name, string value, ConfigNode.Value nodeValue) + { + Assert.Equal(name, nodeValue.name); + Assert.Equal(value, nodeValue.value); + } + } +} diff --git a/TestUtilsTests/TestUtilsTests.csproj b/TestUtilsTests/TestUtilsTests.csproj new file mode 100644 index 00000000..cfe71bf2 --- /dev/null +++ b/TestUtilsTests/TestUtilsTests.csproj @@ -0,0 +1,98 @@ + + + + + + + + Debug + AnyCPU + {E695C11F-4217-4014-9B51-7232A654C205} + Library + Properties + TestUtilsTests + TestUtilsTests + v4.7.1 + 512 + + + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + false + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + false + + + 8.0 + + + + + + + + + + + + ..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll + True + + + ..\packages\xunit.assert.2.4.1\lib\netstandard1.1\xunit.assert.dll + + + ..\packages\xunit.extensibility.core.2.4.1\lib\net452\xunit.core.dll + + + ..\packages\xunit.extensibility.execution.2.4.1\lib\net452\xunit.execution.desktop.dll + + + + + + + + + + + + + + {20eaafe6-510d-4374-8d2f-6b52d0178e85} + TestUtils + + + + + + + + + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + + + + + \ No newline at end of file diff --git a/TestUtilsTests/UrlBuilderTest.cs b/TestUtilsTests/UrlBuilderTest.cs new file mode 100644 index 00000000..38a788f0 --- /dev/null +++ b/TestUtilsTests/UrlBuilderTest.cs @@ -0,0 +1,414 @@ +using System; +using Xunit; +using TestUtils; + +namespace TestUtilsTests +{ + public class UrlBuilderTest + { + [Fact] + public void TestCreateRoot() + { + UrlDir root = UrlBuilder.CreateRoot(); + + Assert.Equal("root", root.name); + Assert.Null(root.parent); + Assert.Same(root, root.root); + } + + [Fact] + public void TestCreateDir() + { + UrlDir dir = UrlBuilder.CreateDir("abc"); + + Assert.Equal("abc", dir.name); + + UrlDir root = dir.parent; + Assert.NotNull(root); + Assert.Equal("root", root.name); + Assert.Null(root.parent); + Assert.Contains(dir, root.children); + + Assert.Same(root, dir.root); + Assert.Same(root, root.root); + } + + [Fact] + public void TestCreateDir__Parent() + { + UrlDir root = UrlBuilder.CreateRoot(); + + UrlDir child1 = UrlBuilder.CreateDir("child1", root); + + Assert.Equal("child1", child1.name); + Assert.Same(root, child1.parent); + Assert.Same(root, child1.root); + + Assert.Equal("child1", child1.url); + + Assert.Contains(child1, root.children); + + UrlDir child2 = UrlBuilder.CreateDir("child2", child1); + + Assert.Equal("child2", child2.name); + Assert.Same(child1, child2.parent); + Assert.Same(root, child2.root); + + Assert.Equal("child1/child2", child2.url); + + Assert.Contains(child2, child1.children); + } + + [Fact] + public void TestCreateDir__Url() + { + UrlDir dir = UrlBuilder.CreateDir("abc/def"); + + Assert.Equal("def", dir.name); + + UrlDir parent = dir.parent; + + Assert.NotNull(parent); + Assert.Equal("abc", parent.name); + Assert.Contains(dir, parent.children); + + UrlDir root = parent.parent; + + Assert.NotNull(root); + Assert.Equal("root", root.name); + Assert.Contains(parent, root.children); + Assert.Null(root.parent); + + Assert.Same(root, root.root); + Assert.Same(root, parent.root); + Assert.Same(root, dir.root); + + Assert.Contains(dir, root.AllDirectories); + } + + [Fact] + public void TestCreateDir__Url__Parent() + { + UrlDir root = UrlBuilder.CreateRoot(); + UrlDir parent1 = UrlBuilder.CreateDir("abc", root); + + UrlDir dir = UrlBuilder.CreateDir("def/ghi", parent1); + + Assert.Equal("ghi", dir.name); + + UrlDir parent2 = dir.parent; + + Assert.NotNull(parent2); + Assert.Equal("def", parent2.name); + Assert.Contains(dir, parent2.children); + + Assert.Same(parent1, parent2.parent); + Assert.Contains(parent2, parent1.children); + + Assert.Same(root, dir.root); + Assert.Same(root, parent2.root); + + Assert.Contains(dir, root.AllDirectories); + Assert.Contains(dir, parent1.AllDirectories); + } + + [Fact] + public void TestCreateDir__Url__AlreadyExists() + { + UrlDir root = UrlBuilder.CreateRoot(); + + UrlDir dir1 = UrlBuilder.CreateDir("abc/def", root); + UrlDir dir2 = UrlBuilder.CreateDir("abc/def", root); + + Assert.Same(dir1, dir2); + + Assert.Equal("def", dir1.name); + + UrlDir parent = dir1.parent; + + Assert.NotNull(parent); + Assert.Equal("abc", parent.name); + Assert.Contains(dir1, parent.children); + + Assert.Same(root, dir1.root); + Assert.Same(root, parent.root); + Assert.Contains(dir1, root.AllDirectories); + } + + [Fact] + public void TestCreateGameData() + { + UrlDir gameData = UrlBuilder.CreateGameData(); + + Assert.Equal("", gameData.name); + Assert.Equal("", gameData.url); + Assert.Equal(UrlDir.DirectoryType.GameData, gameData.type); + UrlDir root = Assert.IsType(gameData.root); + Assert.Same(root, gameData.parent); + Assert.Equal("root", root.name); + Assert.Null(root.parent); + Assert.Same(root, root.root); + Assert.Contains(gameData, root.children); + } + + [Fact] + public void TestCreateGameData__SpecifyRoot() + { + UrlDir root = UrlBuilder.CreateRoot(); + UrlDir gameData = UrlBuilder.CreateGameData(root); + + Assert.Equal("", gameData.name); + Assert.Equal("", gameData.url); + Assert.Equal(UrlDir.DirectoryType.GameData, gameData.type); + Assert.Same(root, gameData.parent); + Assert.Contains(gameData, root.children); + } + + [Fact] + public void TestCreateGameData__SpecifyRoot__GameDataAlreadyExists() + { + UrlDir root = UrlBuilder.CreateRoot(); + UrlDir gameData1 = UrlBuilder.CreateGameData(root); + UrlDir gameData2 = UrlBuilder.CreateGameData(root); + + Assert.Same(gameData1, gameData2); + } + + [Fact] + public void TestCreateFile() + { + UrlDir.UrlFile file = UrlBuilder.CreateFile("someFile.txt"); + + Assert.Equal("someFile", file.name); + Assert.Equal("txt", file.fileExtension); + Assert.Equal(UrlDir.FileType.Unknown, file.fileType); + + UrlDir root = file.parent; + Assert.NotNull(root); + Assert.Equal("root", root.name); + Assert.Null(root.parent); + Assert.Contains(file, root.files); + Assert.Same(root, file.root); + } + + [Fact] + public void TestCreateFile__Parent() + { + UrlDir root = UrlBuilder.CreateRoot(); + UrlDir dir = UrlBuilder.CreateDir("someDir", root); + UrlDir.UrlFile file = UrlBuilder.CreateFile("someFile.txt", dir); + + Assert.Equal("someFile", file.name); + Assert.Equal("txt", file.fileExtension); + Assert.Equal(UrlDir.FileType.Unknown, file.fileType); + Assert.Same(dir, file.parent); + Assert.Same(root, file.root); + + Assert.Equal("someDir/someFile", file.url); + Assert.Contains(file, dir.files); + Assert.Contains(file, root.AllFiles); + } + + [InlineData("dll", UrlDir.FileType.Assembly)] + [InlineData("ksp", UrlDir.FileType.AssetBundle)] + [InlineData("wav", UrlDir.FileType.Audio)] + [InlineData("ogg", UrlDir.FileType.Audio)] + [InlineData("cfg", UrlDir.FileType.Config)] + [InlineData("dae", UrlDir.FileType.Model)] + [InlineData("mu", UrlDir.FileType.Model)] + [InlineData("dds", UrlDir.FileType.Texture)] + [InlineData("jpg", UrlDir.FileType.Texture)] + [InlineData("jpeg", UrlDir.FileType.Texture)] + [InlineData("mbm", UrlDir.FileType.Texture)] + [InlineData("png", UrlDir.FileType.Texture)] + [InlineData("tga", UrlDir.FileType.Texture)] + [InlineData("truecolor", UrlDir.FileType.Texture)] + [InlineData("txt", UrlDir.FileType.Unknown)] + [InlineData("xml", UrlDir.FileType.Unknown)] + [Theory] + public void TestCreateFile__Extension(string extension, UrlDir.FileType fileType) + { + UrlDir.UrlFile file = UrlBuilder.CreateFile("someFile." + extension); + + Assert.Equal("someFile", file.name); + Assert.Equal(extension, file.fileExtension); + Assert.Equal(fileType, file.fileType); + + UrlDir root = file.parent; + Assert.NotNull(root); + Assert.Equal("root", root.name); + Assert.Null(root.parent); + Assert.Contains(file, root.files); + Assert.Same(root, file.root); + } + + [Fact] + public void TestCreateFile__Url() + { + UrlDir.UrlFile file = UrlBuilder.CreateFile("abc/def/ghi.txt"); + + Assert.Equal("ghi", file.name); + Assert.Equal("txt", file.fileExtension); + Assert.Equal(UrlDir.FileType.Unknown, file.fileType); + Assert.Equal("abc/def/ghi", file.url); + + UrlDir parent1 = file.parent; + Assert.NotNull(parent1); + Assert.Equal("def", parent1.name); + Assert.Contains(file, parent1.files); + + UrlDir parent2 = parent1.parent; + Assert.NotNull(parent2); + Assert.Equal("abc", parent2.name); + Assert.Contains(parent1, parent2.children); + + UrlDir root = parent2.parent; + Assert.NotNull(root); + Assert.Equal("root", root.name); + Assert.Contains(parent2, root.children); + Assert.Null(root.parent); + + Assert.Same(root, file.root); + Assert.Same(root, parent1.root); + Assert.Same(root, parent2.root); + Assert.Same(root, root.root); + + Assert.Contains(file, root.AllFiles); + Assert.Contains(file, parent2.AllFiles); + } + + [Fact] + public void TestCreateFile__Url__AlreadyExists() + { + UrlDir root = UrlBuilder.CreateRoot(); + UrlDir.UrlFile file1 = UrlBuilder.CreateFile("abc/def.txt", root); + UrlDir.UrlFile file2 = UrlBuilder.CreateFile("abc/def.txt", root); + + Assert.Same(file1, file2); + + Assert.Equal("def", file1.name); + Assert.Equal("txt", file1.fileExtension); + Assert.Equal(UrlDir.FileType.Unknown, file1.fileType); + Assert.Equal("abc/def", file1.url); + + UrlDir parent1 = file1.parent; + Assert.NotNull(parent1); + Assert.Equal("abc", parent1.name); + Assert.Contains(file1, parent1.files); + + Assert.Same(root, file1.root); + Assert.Same(root, parent1.root); + + Assert.Contains(file1, root.AllFiles); + } + + [Fact] + public void TestCreateConfig() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "name", "blah" }, + { "foo", "bar" }, + }; + UrlDir.UrlFile file = UrlBuilder.CreateFile("abc/def.cfg"); + UrlDir.UrlConfig config = UrlBuilder.CreateConfig(node, file); + + Assert.Equal("SOME_NODE", config.type); + Assert.Equal("blah", config.name); + Assert.Same(node, config.config); + Assert.Equal("abc/def/blah", config.url); // I don't know why this is correct, but it is + Assert.Same(file, config.parent); + Assert.Contains(config, file.configs); + } + + [Fact] + public void TestCreateConfig__Url() + { + ConfigNode node = new TestConfigNode("SOME_NODE") + { + { "name", "blah" }, + { "foo", "bar" }, + }; + UrlDir.UrlConfig config = UrlBuilder.CreateConfig("abc/def", node); + + Assert.Equal("SOME_NODE", config.type); + Assert.Equal("blah", config.name); + Assert.Same(node, config.config); + Assert.Equal("abc/def/blah", config.url); + + UrlDir.UrlFile file = config.parent; + Assert.NotNull(file); + Assert.Equal("def", file.name); + Assert.Equal("cfg", file.fileExtension); + Assert.Equal(UrlDir.FileType.Config, file.fileType); + Assert.Contains(config, file.configs); + + UrlDir parent = file.parent; + Assert.NotNull(parent); + Assert.Equal("abc", parent.name); + Assert.Contains(file, parent.files); + + UrlDir root = parent.parent; + Assert.NotNull(root); + Assert.Equal("root", root.name); + Assert.Contains(parent, root.children); + Assert.Null(root.parent); + + Assert.Same(root, file.root); + Assert.Same(root, parent.root); + Assert.Same(root, root.root); + + Assert.Contains(config, root.AllConfigs); + Assert.Contains(config, root.GetConfigs("SOME_NODE")); + } + + [Fact] + public void TestCreateConfig__Url__FileAlreadyExists() + { + UrlDir root = UrlBuilder.CreateRoot(); + + ConfigNode node1 = new TestConfigNode("SOME_NODE") + { + { "name", "blah" }, + { "foo", "bar" }, + }; + + ConfigNode node2 = new TestConfigNode("SOME_OTHER_NODE") + { + { "name", "bleh" }, + { "jazz", "hands" }, + }; + + UrlDir.UrlConfig config1 = UrlBuilder.CreateConfig("abc/def", node1, root); + UrlDir.UrlConfig config2 = UrlBuilder.CreateConfig("abc/def", node2, root); + + UrlDir.UrlFile file = config1.parent; + Assert.NotNull(file); + + Assert.Same(file, config2.parent); + + Assert.Equal("def", file.name); + Assert.Equal("cfg", file.fileExtension); + Assert.Equal(UrlDir.FileType.Config, file.fileType); + Assert.Contains(config1, file.configs); + Assert.Contains(config2, file.configs); + + UrlDir parent = file.parent; + Assert.NotNull(parent); + Assert.Equal("abc", parent.name); + Assert.Contains(file, parent.files); + + Assert.Contains(parent, root.children); + + Assert.Same(root, file.root); + Assert.Same(root, parent.root); + Assert.Same(root, root.root); + + Assert.Contains(config1, root.AllConfigs); + Assert.Contains(config1, root.GetConfigs("SOME_NODE")); + + Assert.Contains(config2, root.AllConfigs); + Assert.Contains(config2, root.GetConfigs("SOME_OTHER_NODE")); + } + } +} diff --git a/TestUtilsTests/packages.config b/TestUtilsTests/packages.config new file mode 100644 index 00000000..8cf69e4f --- /dev/null +++ b/TestUtilsTests/packages.config @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/moduleManager.cs b/moduleManager.cs deleted file mode 100644 index 49e71746..00000000 --- a/moduleManager.cs +++ /dev/null @@ -1,3133 +0,0 @@ -using System; -using System.Collections; -using System.Collections.Generic; -using System.Diagnostics; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Text; -using System.Text.RegularExpressions; -using UnityEngine; -using Debug = UnityEngine.Debug; - -namespace ModuleManager -{ - [KSPAddon(KSPAddon.Startup.Instantly, false)] - public class ModuleManager : MonoBehaviour - { - #region state - - private bool inRnDCenter; - - private bool reloading; - - public bool showUI = false; - - private Rect windowPos = new Rect(80f, 60f, 240f, 40f); - - private string version = ""; - - private Texture2D tex; - private Texture2D tex2; - private int activePos = 0; - - private bool nyan = false; - - #endregion state - - #region Top Level - Update - - private static bool loadedInScene; - - internal void OnRnDCenterSpawn() - { - inRnDCenter = true; - } - - internal void OnRnDCenterDeSpawn() - { - inRnDCenter = false; - } - - public static void log(String s) - { - print("[ModuleManager] " + s); - } - - private Stopwatch totalTime = new Stopwatch(); - - internal void Awake() - { - totalTime.Start(); - - // Allow loading the background in the laoding screen - Application.runInBackground = true; - - // Ensure that only one copy of the service is run per scene change. - if (loadedInScene || !ElectionAndCheck()) - { - Assembly currentAssembly = Assembly.GetExecutingAssembly(); - log("Multiple copies of current version. Using the first copy. Version: " + - currentAssembly.GetName().Version); - Destroy(gameObject); - return; - } - DontDestroyOnLoad(gameObject); - - Version v = Assembly.GetExecutingAssembly().GetName().Version; - version = v.Major + "." + v.Minor + "." + v.Build; - - // Subscribe to the RnD center spawn/deSpawn events - GameEvents.onGUIRnDComplexSpawn.Add(OnRnDCenterSpawn); - GameEvents.onGUIRnDComplexDespawn.Add(OnRnDCenterDeSpawn); - - - LoadingScreen screen = FindObjectOfType(); - if (screen == null) - { - log("Can't find LoadingScreen type. Aborting ModuleManager execution"); - return; - } - List list = LoadingScreen.Instance.loaders; - - if (list != null) - { - // So you can insert a LoadingSystem object in this list at any point. - // GameDatabase is first in the list, and PartLoader is second - // We could insert ModuleManager after GameDatabase to get it to run there - // and SaveGameFixer after PartLoader. - - GameObject aGameObject = new GameObject("ModuleManager"); - MMPatchLoader loader = aGameObject.AddComponent(); - - log(string.Format("Adding ModuleManager to the loading screen {0}", list.Count)); - list.Insert(1, loader); - } - - tex = new Texture2D(33, 20, TextureFormat.ARGB32, false); - tex.LoadImage(Properties.Resources.cat); - Color[] pix = tex.GetPixels(0, 0, 1, tex.height); - tex2 = new Texture2D(1, 20, TextureFormat.ARGB32, false); - tex2.SetPixels(pix); - tex2.Apply(); - - nyan = (DateTime.Now.Month == 4 && DateTime.Now.Day == 1) || - Environment.GetCommandLineArgs().Contains("-nyan-nyan"); - - loadedInScene = true; - } - - // Unsubscribe from events when the behavior dies - internal void OnDestroy() - { - GameEvents.onGUIRnDComplexSpawn.Remove(OnRnDCenterSpawn); - GameEvents.onGUIRnDComplexDespawn.Remove(OnRnDCenterDeSpawn); - } - - internal void Update() - { - if (GameSettings.MODIFIER_KEY.GetKey() && Input.GetKeyDown(KeyCode.F11)) - showUI = !showUI; - - if (totalTime.IsRunning && HighLogic.LoadedScene == GameScenes.MAINMENU) - { - totalTime.Stop(); - log("Total loading Time = " + ((float)totalTime.ElapsedMilliseconds / 1000).ToString("F3") + "s"); - - Application.runInBackground = GameSettings.SIMULATE_IN_BACKGROUND; - - } - - if (reloading) - { - float percent = 0; - if (!GameDatabase.Instance.IsReady()) - percent = GameDatabase.Instance.ProgressFraction(); - else if (!MMPatchLoader.Instance.IsReady()) - percent = 1f + MMPatchLoader.Instance.ProgressFraction(); - else if (!PartLoader.Instance.IsReady()) - percent = 2f + PartLoader.Instance.ProgressFraction(); - - int intPercent = Mathf.CeilToInt(percent * 100f / 3f); - ScreenMessages.PostScreenMessage("Database reloading " + intPercent + "%", Time.deltaTime, - ScreenMessageStyle.UPPER_CENTER); - } - } - - #region GUI stuff. - - public void OnGUI() - { - if (HighLogic.LoadedScene == GameScenes.LOADING && MMPatchLoader.Instance != null) - { - float offsetY = Mathf.FloorToInt(0.8f * Screen.height); - - if (Versioning.version_major == 1 && Versioning.version_minor == 0 && Versioning.Revision == 5 && Versioning.BuildID == 1024) - { - GUIStyle centeredWarningStyle = new GUIStyle(GUI.skin.GetStyle("Label")) - { - alignment = TextAnchor.UpperCenter, - fontSize = 16, - normal = { textColor = Color.yellow } - }; - const string warning = "Your KSP 1.0.5 is running on build 1024. You should upgrade to build 1028 to avoid problems with addons."; - - Vector2 sizeOfWarningLabel = centeredWarningStyle.CalcSize(new GUIContent(warning)); - - GUI.Label(new Rect(Screen.width / 2f - (sizeOfWarningLabel.x / 2f), offsetY, sizeOfWarningLabel.x, sizeOfWarningLabel.y), warning, centeredWarningStyle); - - offsetY += sizeOfWarningLabel.y; - if (GUI.Button(new Rect(Screen.width/2f - 100, offsetY, 200, 20), "Click to open the Forum thread")) - Application.OpenURL("http://forum.kerbalspaceprogram.com/index.php?/topic/124998-silent-patch-for-ksp-105-published/"); - - offsetY += 25; - } - - //if (IsABadIdea()) - //{ - // GUIStyle centeredWarningStyle = new GUIStyle(GUI.skin.GetStyle("Label")) - // { - // alignment = TextAnchor.UpperCenter, - // fontSize = 16, - // normal = { textColor = Color.yellow } - // }; - // const string warning = "You are using 64-bit KSP on Windows. This version of KSP is known to cause crashes unrelated to mods."; - // Vector2 sizeOfWarningLabel = centeredWarningStyle.CalcSize(new GUIContent(warning)); - // - // GUI.Label(new Rect(Screen.width / 2f - (sizeOfWarningLabel.x / 2f), offsetY, sizeOfWarningLabel.x, sizeOfWarningLabel.y), warning, centeredWarningStyle); - // offsetY += sizeOfWarningLabel.y; - //} - - GUIStyle centeredStyle = new GUIStyle(GUI.skin.GetStyle("Label")) - { - alignment = TextAnchor.UpperCenter, - fontSize = 16 - }; - Vector2 sizeOfLabel = centeredStyle.CalcSize(new GUIContent(MMPatchLoader.Instance.status)); - GUI.Label(new Rect(Screen.width / 2f - (sizeOfLabel.x / 2f), offsetY, sizeOfLabel.x, sizeOfLabel.y), MMPatchLoader.Instance.status, centeredStyle); - offsetY += sizeOfLabel.y; - - if (MMPatchLoader.Instance.errorCount > 0) - { - GUIStyle errorStyle = new GUIStyle(GUI.skin.GetStyle("Label")) - { - alignment = TextAnchor.UpperLeft, - fontSize = 16 - }; - Vector2 sizeOfError = errorStyle.CalcSize(new GUIContent(MMPatchLoader.Instance.errors)); - GUI.Label(new Rect(Screen.width / 2f - (sizeOfLabel.x / 2), offsetY, sizeOfError.x, sizeOfError.y), MMPatchLoader.Instance.errors, errorStyle); - offsetY += sizeOfError.y; - } - - - if (nyan) - { - GUI.color = Color.white; - int scale = 1; - if (Screen.height >= 1080) - scale = 2; - if (Screen.height > 1440) - scale = 3; - - int trailLength = 8 * tex.width * scale; - int totalLenth = trailLength + tex.width * scale; - int startPos = activePos - totalLenth; - - Color guiColor = Color.white; - int currentOffset = 0; - int heightOffset = 0; - while (currentOffset < trailLength) - { - guiColor.a = (float)currentOffset / trailLength; - GUI.color = guiColor; - - heightOffset = Mathf.RoundToInt(1f + Mathf.Sin(2f * Mathf.PI * (startPos + currentOffset) / (Screen.width / 6f)) * (tex.height * scale / 6f)); - - GUI.DrawTexture(new Rect(startPos + currentOffset, heightOffset + offsetY, tex2.width, tex2.height * scale), tex2); - currentOffset++; - } - GUI.DrawTexture(new Rect(startPos + currentOffset, heightOffset + offsetY, tex.width * scale, tex.height * scale), tex); - - activePos = (activePos + 3) % (Screen.width + totalLenth); - GUI.color = Color.white; - } - } - - - if (showUI && - (HighLogic.LoadedScene == GameScenes.SPACECENTER || HighLogic.LoadedScene == GameScenes.MAINMENU) && - !inRnDCenter) - { - windowPos = GUILayout.Window( - GetType().FullName.GetHashCode(), - windowPos, - WindowGUI, - "ModuleManager " + version, - GUILayout.Width(200), - GUILayout.Height(20)); - } - } - - - internal static IntPtr intPtr = new IntPtr(long.MaxValue); - /* Not required anymore. At least - public static bool IsABadIdea() - { - return (intPtr.ToInt64() == long.MaxValue) && (Environment.OSVersion.Platform == PlatformID.Win32NT); - } - */ - - private void WindowGUI(int windowID) - { - GUILayout.BeginVertical(); - - if (GUILayout.Button("Reload Database")) - { - MMPatchLoader.keepPartDB = false; - StartCoroutine(DataBaseReloadWithMM()); - } - if (GUILayout.Button("Quick Reload Database")) - { - MMPatchLoader.keepPartDB = true; - StartCoroutine(DataBaseReloadWithMM()); - } - if (GUILayout.Button("Dump Database to File")) - StartCoroutine(DataBaseReloadWithMM(true)); - GUILayout.EndVertical(); - GUI.DragWindow(); - } - - private IEnumerator DataBaseReloadWithMM(bool dump = false) - { - reloading = true; - - QualitySettings.vSyncCount = 0; - Application.targetFrameRate = -1; - - ScreenMessages.PostScreenMessage("Database reloading started", 1, ScreenMessageStyle.UPPER_CENTER); - yield return null; - - GameDatabase.Instance.Recompile = true; - GameDatabase.Instance.StartLoad(); - - // wait for it to finish - while (!GameDatabase.Instance.IsReady()) - yield return null; - - MMPatchLoader.Instance.StartLoad(); - - while (!MMPatchLoader.Instance.IsReady()) - yield return null; - - log("DB Reload OK with patchCount=" + MMPatchLoader.Instance.patchedNodeCount + " errorCount=" + - MMPatchLoader.Instance.errorCount + " needsUnsatisfiedCount=" + - MMPatchLoader.Instance.needsUnsatisfiedCount); - - PartResourceLibrary.Instance.LoadDefinitions(); - - if (dump) - OutputAllConfigs(); - - PartLoader.Instance.StartLoad(); - - while (!PartLoader.Instance.IsReady()) - yield return null; - - // Needs more work. - //ConfigNode game = HighLogic.CurrentGame.config.GetNode("GAME"); - - //if (game != null && ResearchAndDevelopment.Instance != null) - //{ - // ScreenMessages.PostScreenMessage("GAME found"); - // ConfigNode scenario = game.GetNodes("SCENARIO").FirstOrDefault((ConfigNode n) => n.name == "ResearchAndDevelopment"); - // if (scenario != null) - // { - // ScreenMessages.PostScreenMessage("SCENARIO found"); - // ResearchAndDevelopment.Instance.OnLoad(scenario); - // } - //} - - QualitySettings.vSyncCount = GameSettings.SYNC_VBL; - Application.targetFrameRate = GameSettings.FRAMERATE_LIMIT; - reloading = false; - ScreenMessages.PostScreenMessage("Database reloading finished", 1, ScreenMessageStyle.UPPER_CENTER); - } - - private static void OutputAllConfigs() - { - string path = KSPUtil.ApplicationRootPath + Path.DirectorySeparatorChar + "_MMCfgOutput" - + Path.DirectorySeparatorChar; - Directory.CreateDirectory(path); - - foreach (UrlDir.UrlConfig d in GameDatabase.Instance.root.AllConfigs) - File.WriteAllText(path + d.url.Replace('/', '.') + ".cfg", d.config.ToString()); - } - - #endregion GUI stuff. - - public bool ElectionAndCheck() - { - #region Type election - - // TODO : Move the old version check in a process that call Update. - - // Check for old version and MMSarbianExt - IEnumerable oldMM = - AssemblyLoader.loadedAssemblies.Where( - a => a.assembly.GetName().Name == Assembly.GetExecutingAssembly().GetName().Name) - .Where(a => a.assembly.GetName().Version.CompareTo(new System.Version(1, 5, 0)) == -1); - IEnumerable oldAssemblies = - oldMM.Concat(AssemblyLoader.loadedAssemblies.Where(a => a.assembly.GetName().Name == "MMSarbianExt")); - if (oldAssemblies.Any()) - { - IEnumerable badPaths = - oldAssemblies.Select(a => a.path) - .Select( - p => - Uri.UnescapeDataString( - new Uri(Path.GetFullPath(KSPUtil.ApplicationRootPath)).MakeRelativeUri(new Uri(p)) - .ToString() - .Replace('/', Path.DirectorySeparatorChar))); - string status = - "You have old versions of Module Manager (older than 1.5) or MMSarbianExt.\nYou will need to remove them for Module Manager and the mods using it to work\nExit KSP and delete those files :\n" + - String.Join("\n", badPaths.ToArray()); - PopupDialog.SpawnPopupDialog(new Vector2(0f, 1f), new Vector2(0f, 1f), "Old versions of Module Manager", status, "OK", false, UISkinManager.defaultSkin); - log("Old version of Module Manager present. Stopping"); - return false; - } - - - //PopupDialog.SpawnPopupDialog(new Vector2(0.1f, 1f), new Vector2(0.2f, 1f), "Test of the dialog", "Stuff", "OK", false, UISkinManager.defaultSkin); - - Assembly currentAssembly = Assembly.GetExecutingAssembly(); - IEnumerable eligible = from a in AssemblyLoader.loadedAssemblies - let ass = a.assembly - where ass.GetName().Name == currentAssembly.GetName().Name - orderby ass.GetName().Version descending, a.path ascending - select a; - - // Elect the newest loaded version of MM to process all patch files. - // If there is a newer version loaded then don't do anything - // If there is a same version but earlier in the list, don't do anything either. - if (eligible.First().assembly != currentAssembly) - { - //loaded = true; - log("version " + currentAssembly.GetName().Version + " at " + currentAssembly.Location + - " lost the election"); - Destroy(gameObject); - return false; - } - string candidates = ""; - foreach (AssemblyLoader.LoadedAssembly a in eligible) - { - if (currentAssembly.Location != a.path) - candidates += "Version " + a.assembly.GetName().Version + " " + a.path + " " + "\n"; - } - if (candidates.Length > 0) - { - log("version " + currentAssembly.GetName().Version + " at " + currentAssembly.Location + - " won the election against\n" + candidates); - } - - #endregion Type election - - return true; - } - } - - public delegate void ModuleManagerPostPatchCallback(); - - public class MMPatchLoader : LoadingSystem - { - public int totalPatchCount = 0; - - public int appliedPatchCount = 0; - - public int patchedNodeCount = 0; - - public int errorCount = 0; - - public int needsUnsatisfiedCount = 0; - - private int catEatenCount = 0; - - private Dictionary errorFiles; - - private List mods; - - public string status = ""; - - public string errors = ""; - - public static bool keepPartDB = false; - - private string activity = "Module Manager"; - - private static readonly Dictionary regexCache = new Dictionary(); - - private static readonly Stack nodeStack = new Stack(); - - private static ConfigNode topNode; - - private static string cachePath = KSPUtil.ApplicationRootPath + Path.DirectorySeparatorChar + "GameData" - + Path.DirectorySeparatorChar + "ModuleManager.ConfigCache"; - - internal static readonly string techTreeFile = "GameData" + Path.DirectorySeparatorChar + "ModuleManager.TechTree"; - internal static readonly string techTreePath = KSPUtil.ApplicationRootPath + Path.DirectorySeparatorChar + techTreeFile; - - internal static readonly string physicsFile = "GameData" + Path.DirectorySeparatorChar + "ModuleManager.Physics"; - internal static readonly string physicsPath = KSPUtil.ApplicationRootPath + Path.DirectorySeparatorChar + physicsFile; - private static readonly string defaultPhysicsPath = KSPUtil.ApplicationRootPath + Path.DirectorySeparatorChar + "Physics.cfg"; - - internal static readonly string partDatabasePath = KSPUtil.ApplicationRootPath + Path.DirectorySeparatorChar + "PartDatabase.cfg"; - - private static readonly string shaPath = KSPUtil.ApplicationRootPath + Path.DirectorySeparatorChar + "GameData" - + Path.DirectorySeparatorChar + "ModuleManager.ConfigSHA"; - - private UrlDir.UrlFile physicsUrlFile; - - private string configSha; - private Dictionary filesSha = new Dictionary(); - - private bool useCache = false; - - private readonly Stopwatch patchSw = new Stopwatch(); - - private static readonly List postPatchCallbacks = - new List(); - - private const float yieldInterval = 1f/30f; // Patch at ~30fps - - public static MMPatchLoader Instance { get; private set; } - - private void Awake() - { - if (Instance != null) - { - DestroyImmediate(this); - return; - } - Instance = this; - DontDestroyOnLoad(gameObject); - } - - private bool ready; - - public override bool IsReady() - { - if (ready) - { - patchSw.Stop(); - log("Ran in " + ((float)patchSw.ElapsedMilliseconds / 1000).ToString("F3") + "s"); - - } - return ready; - } - - public override float ProgressFraction() - { - if (totalPatchCount > 0) - return (appliedPatchCount + needsUnsatisfiedCount) / (float)totalPatchCount; - return 0; - } - - public override string ProgressTitle() - { - return activity; - } - - public override void StartLoad() - { - StartLoad(false); - } - - public void Update() - { - if (appliedPatchCount > 0 && HighLogic.LoadedScene == GameScenes.LOADING) - StatusUpdate(); - } - - public void StartLoad(bool blocking) - { - patchSw.Reset(); - patchSw.Start(); - - totalPatchCount = 0; - appliedPatchCount = 0; - patchedNodeCount = 0; - errorCount = 0; - needsUnsatisfiedCount = 0; - errorFiles = new Dictionary(); - - #endregion Top Level - Update - - ready = false; - - // DB check used to track the now fixed TextureReplacer corruption - //checkValues(); - - StartCoroutine(ProcessPatch(blocking), blocking); - } - - public static void addPostPatchCallback(ModuleManagerPostPatchCallback callback) - { - if (!postPatchCallbacks.Contains(callback)) - postPatchCallbacks.Add(callback); - } - private List PrePatchInit() - { - #region Excluding directories - - // Build a list of subdirectory that won't be processed - List excludePaths = new List(); - - //if (ModuleManager.IsABadIdea()) - //{ - // foreach (UrlDir.UrlConfig mod in GameDatabase.Instance.root.AllConfigs) - // { - // if (mod.name == "MODULEMANAGER[NOWIN64]") - // { - // string fullpath = mod.url.Substring(0, mod.url.LastIndexOf('/')); - // string excludepath = fullpath.Substring(0, fullpath.LastIndexOf('/')); - // excludePaths.Add(excludepath); - // log("excludepath: " + excludepath); - // } - // } - // if (excludePaths.Any()) - // log("will not process patches in these subdirectories since they were disbaled on KSP Win64:\n" + String.Join("\n", excludePaths.ToArray())); - //} - - #endregion Excluding directories - - #region List of mods - - //string envInfo = "ModuleManager env info\n"; - //envInfo += " " + Environment.OSVersion.Platform + " " + ModuleManager.intPtr.ToInt64().ToString("X16") + "\n"; - //envInfo += " " + Convert.ToString(ModuleManager.intPtr.ToInt64(), 2) + " " + Convert.ToString(ModuleManager.intPtr.ToInt64() >> 63, 2) + "\n"; - //string gamePath = Environment.GetCommandLineArgs()[0]; - //envInfo += " Args: " + gamePath.Split(Path.DirectorySeparatorChar).Last() + " " + string.Join(" ", Environment.GetCommandLineArgs().Skip(1).ToArray()) + "\n"; - //envInfo += " Executable SHA256 " + FileSHA(gamePath); - // - //log(envInfo); - - mods = new List(); - - string modlist = "compiling list of loaded mods...\nMod DLLs found:\n"; - - foreach (AssemblyLoader.LoadedAssembly mod in AssemblyLoader.loadedAssemblies) - { - - if (string.IsNullOrEmpty(mod.assembly.Location)) //Diazo Edit for xEvilReeperx AssemblyReloader mod - continue; - - FileVersionInfo fileVersionInfo = FileVersionInfo.GetVersionInfo(mod.assembly.Location); - - AssemblyName assemblyName = mod.assembly.GetName(); - - string modInfo = " " + assemblyName.Name - + " v" + assemblyName.Version - + - (fileVersionInfo.ProductVersion != " " && fileVersionInfo.ProductVersion != assemblyName.Version.ToString() - ? " / v" + fileVersionInfo.ProductVersion - : "") - + - (fileVersionInfo.FileVersion != " " &&fileVersionInfo.FileVersion != assemblyName.Version.ToString() && fileVersionInfo.FileVersion != fileVersionInfo.ProductVersion - ? " / v" + fileVersionInfo.FileVersion - : ""); - - modlist += String.Format(" {0,-50} SHA256 {1}\n", modInfo, FileSHA(mod.assembly.Location)); - - if (!mods.Contains(assemblyName.Name, StringComparer.OrdinalIgnoreCase)) - mods.Add(assemblyName.Name); - } - - modlist += "Non-DLL mods added (:FOR[xxx]):\n"; - foreach (UrlDir.UrlConfig cfgmod in GameDatabase.Instance.root.AllConfigs) - { - string name; - if (ParseCommand(cfgmod.type, out name) != Command.Insert) - { - totalPatchCount++; - if (name.Contains(":FOR[")) - { - name = RemoveWS(name); - - // check for FOR[] blocks that don't match loaded DLLs and add them to the pass list - try - { - string dependency = name.Substring(name.IndexOf(":FOR[") + 5); - dependency = dependency.Substring(0, dependency.IndexOf(']')); - if (!mods.Contains(dependency, StringComparer.OrdinalIgnoreCase)) - { - // found one, now add it to the list. - mods.Add(dependency); - modlist += " " + dependency + "\n"; - } - } - catch (ArgumentOutOfRangeException) - { - log("Skipping :FOR init for line " + name + - ". The line most likely contain a space that should be removed"); - } - } - } - } - modlist += "Mods by directory (sub directories of GameData):\n"; - string gameData = Path.Combine(Path.GetFullPath(KSPUtil.ApplicationRootPath), "GameData"); - foreach (string subdir in Directory.GetDirectories(gameData)) - { - string name = Path.GetFileName(subdir); - string cleanName = RemoveWS(name); - if (!mods.Contains(cleanName, StringComparer.OrdinalIgnoreCase)) - { - mods.Add(cleanName); - modlist += " " + cleanName + "\n"; - } - } - log(modlist); - - mods.Sort(); - - return excludePaths; - - #endregion List of mods - } - - - Coroutine StartCoroutine(IEnumerator enumerator, bool blocking) - { - if (blocking) - { - while (enumerator.MoveNext()) { } - return null; - } - else - { - return StartCoroutine(enumerator); - } - } - - private IEnumerator ProcessPatch(bool blocking) - { - try - { - IsCacheUpToDate(); - } - catch (Exception ex) - { - log("Exception in IsCacheUpToDate : " + ex.Message + "\n" + ex.StackTrace); - useCache = false; - } - -#if DEBUG - //useCache = false; -#endif - - yield return null; - - List excludePaths = PrePatchInit(); - - yield return null; - - if (!useCache) - { - // If we don't use the cache then it is best to clean the PartDatabase.cfg - if (!keepPartDB && File.Exists(partDatabasePath)) - File.Delete(partDatabasePath); - - LoadPhysicsConfig(); - - #region Check Needs - - // Do filtering with NEEDS - log("Checking NEEDS."); - - CheckNeeds(excludePaths); - - #endregion Check Needs - - yield return null; - - #region Applying patches - - log("Applying patches"); - - // :First node - yield return StartCoroutine(ApplyPatch(excludePaths, ":FIRST"), blocking); - - // any node without a :pass - yield return StartCoroutine(ApplyPatch(excludePaths, ":LEGACY"), blocking); - - foreach (string mod in mods) - { - string upperModName = mod.ToUpper(); - yield return StartCoroutine(ApplyPatch(excludePaths, ":BEFORE[" + upperModName + "]"), blocking); - yield return StartCoroutine(ApplyPatch(excludePaths, ":FOR[" + upperModName + "]"), blocking); - yield return StartCoroutine(ApplyPatch(excludePaths, ":AFTER[" + upperModName + "]"), blocking); - } - - // :Final node - yield return StartCoroutine(ApplyPatch(excludePaths, ":FINAL"), blocking); - - - PurgeUnused(excludePaths); - - #endregion Applying patches - - #region Logging - - if (errorCount > 0) - { - foreach (string file in errorFiles.Keys) - { - errors += errorFiles[file] + " error" + (errorFiles[file] > 1 ? "s" : "") + " related to GameData/" + file - + "\n"; - } - - log("Errors in patch prevents the creation of the cache"); - try - { - if (File.Exists(cachePath)) - File.Delete(cachePath); - if (File.Exists(shaPath)) - File.Delete(shaPath); - } - catch (Exception e) - { - log("Exception while deleting stale cache " + e); - } - } - else - { - CreateCache(); - } - - SaveModdedTechTree(); - SaveModdedPhysics(); - } - else - { - log("Loading from Cache"); - LoadCache(); - } - - StatusUpdate(); - - log(status + "\n" + errors); - - #endregion Logging - -#if DEBUG - RunTestCases(); -#endif - - // TODO : Remove if we ever get a way to load sooner - log("Reloading ressources definitions"); - PartResourceLibrary.Instance.LoadDefinitions(); - - foreach (ModuleManagerPostPatchCallback callback in postPatchCallbacks) - { - try - { - callback(); - } - catch (Exception e) - { - log("Exception while running a post patch callback\n" + e); - } - yield return null; - } - yield return null; - - // Call all "public static void ModuleManagerPostLoad()" on all class - foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies()) - { - try - { - foreach (Type type in ass.GetTypes()) - { - MethodInfo method = type.GetMethod("ModuleManagerPostLoad", BindingFlags.Public | BindingFlags.Static); - - if (method != null && method.GetParameters().Length == 0) - { - try - { - log("Calling " + ass.GetName().Name + "." + type.Name + "." + method.Name + "()"); - method.Invoke(null, null); - } - catch (Exception e) - { - log("Exception while calling " + ass.GetName().Name + "." + type.Name + "." + method.Name + "() :\n" + e); - } - } - } - } - catch (Exception e) - { - log("Post run call threw an exception in loading " + ass.FullName + ": " + e); - } - } - - yield return null; - - // Call "public void ModuleManagerPostLoad()" on all active MonoBehaviour instance - foreach (MonoBehaviour obj in FindObjectsOfType()) - { - MethodInfo method = obj.GetType().GetMethod("ModuleManagerPostLoad", BindingFlags.Public | BindingFlags.Instance); - - if (method != null && method.GetParameters().Length == 0) - { - try - { - log("Calling " + obj.GetType().Name + "." + method.Name + "()"); - method.Invoke(obj, null); - } - catch (Exception e) - { - log("Exception while calling " + obj.GetType().Name + "." + method.Name + "() :\n" + e); - } - } - } - - yield return null; - - ready = true; - } - - private void LoadPhysicsConfig() - { - log("Loading Physics.cfg"); - UrlDir gameDataDir = GameDatabase.Instance.root.AllDirectories.First(d => d.path.EndsWith("GameData") && d.name == "" && d.url == ""); - // need to use a file with a cfg extenssion to get the right fileType or you can't AddConfig on it - physicsUrlFile = new UrlDir.UrlFile(gameDataDir, new FileInfo(defaultPhysicsPath)); - // Since it loaded the default config badly (sub node only) we clear it first - physicsUrlFile.configs.Clear(); - // And reload it properly - ConfigNode physicsContent = ConfigNode.Load(defaultPhysicsPath); - physicsContent.name = "PHYSICSGLOBALS"; - physicsUrlFile.AddConfig(physicsContent); - gameDataDir.files.Add(physicsUrlFile); - } - - - private void SaveModdedPhysics() - { - List configs = physicsUrlFile.configs; - - if (configs.Count == 0) - { - log("No PHYSICSGLOBALS node found. No custom Physics config will be saved"); - return; - } - - if (configs.Count > 1) - { - log(configs.Count + " PHYSICSGLOBALS node found. A patch may be wrong. Using the first one"); - } - - configs[0].config.Save(physicsPath); - } - - - // DB check used to track the now fixed TextureReplacer corruption - public static void checkValues() - { - foreach (UrlDir.UrlConfig mod in GameDatabase.Instance.root.AllConfigs) - { - if (checkValues(mod.config)) - { - log("Found bad value"); - return; - } - } - log("Found no bad value"); - } - - static bool checkValues(ConfigNode node) - { - foreach (ConfigNode.Value value in node.values) - { - if (value.name.Length == -1) - return true; - } - - foreach (ConfigNode subNode in node.nodes) - { - if (checkValues(subNode)) - return true; - } - return false; - } - - private string FileSHA(string filename) - { - try - { - if (File.Exists(filename)) - { - System.Security.Cryptography.SHA256 sha = System.Security.Cryptography.SHA256.Create(); - - byte[] data = null; - using (FileStream fs = File.Open(filename, FileMode.Open, FileAccess.Read)) - { - data = sha.ComputeHash(fs); - } - - string hashedValue = string.Empty; - - foreach (byte b in data) - { - hashedValue += String.Format("{0,2:x2}", b); - } - - return hashedValue; - } - } - catch (Exception e) - { - log("Exception hashing file " + filename + "\n" + e.ToString()); - return "0"; - } - return "0"; - } - - private void IsCacheUpToDate() - { - Stopwatch sw = new Stopwatch(); - sw.Start(); - - System.Security.Cryptography.SHA256 sha = System.Security.Cryptography.SHA256.Create(); - System.Security.Cryptography.SHA256 filesha = System.Security.Cryptography.SHA256.Create(); - UrlDir.UrlFile[] files = GameDatabase.Instance.root.AllConfigFiles.ToArray(); - for (int i = 0; i < files.Length; i++) - { - // Hash the file path so the checksum change if files are moved - byte[] pathBytes = Encoding.UTF8.GetBytes(files[i].url); - sha.TransformBlock(pathBytes, 0, pathBytes.Length, pathBytes, 0); - - // hash the file content - byte[] contentBytes = File.ReadAllBytes(files[i].fullPath); - if (i == files.Length - 1) - sha.TransformFinalBlock(contentBytes, 0, contentBytes.Length); - else - sha.TransformBlock(contentBytes, 0, contentBytes.Length, contentBytes, 0); - - - filesha.ComputeHash(contentBytes); - filesSha.Add(files[i].url, BitConverter.ToString(filesha.Hash)); - - } - - // Hash the mods dll path so the checksum change if dlls are moved or removed (impact NEEDS) - foreach (AssemblyLoader.LoadedAssembly dll in AssemblyLoader.loadedAssemblies) - { - string path = dll.url + "/" + dll.name; - byte[] pathBytes = Encoding.UTF8.GetBytes(path); - sha.TransformBlock(pathBytes, 0, pathBytes.Length, pathBytes, 0); - } - - configSha = BitConverter.ToString(sha.Hash); - sha.Clear(); - filesha.Clear(); - - sw.Stop(); - - log("SHA generated in " + ((float)sw.ElapsedMilliseconds / 1000).ToString("F3") + "s"); - log(" SHA = " + configSha); - - useCache = false; - if (File.Exists(shaPath)) - { - ConfigNode shaConfigNode = ConfigNode.Load(shaPath); - if (shaConfigNode != null && shaConfigNode.HasValue("SHA") && shaConfigNode.HasValue("version") && shaConfigNode.HasValue("KSPVersion")) - { - string storedSHA = shaConfigNode.GetValue("SHA"); - string version = shaConfigNode.GetValue("version"); - string kspVersion = shaConfigNode.GetValue("KSPVersion"); - ConfigNode filesShaNode = shaConfigNode.GetNode("FilesSHA"); - useCache = CheckFilesChange(files, filesShaNode); - useCache = useCache && storedSHA.Equals(configSha); - useCache = useCache && version.Equals(Assembly.GetExecutingAssembly().GetName().Version.ToString()); - useCache = useCache && kspVersion.Equals(Versioning.version_major + "." + Versioning.version_minor + "." + Versioning.Revision + "." + Versioning.BuildID); - useCache = useCache && File.Exists(cachePath); - useCache = useCache && File.Exists(physicsPath); - useCache = useCache && File.Exists(techTreePath); - log("Cache SHA = " + storedSHA); - log("useCache = " + useCache); - } - } - } - - private bool CheckFilesChange(UrlDir.UrlFile[] files, ConfigNode shaConfigNode) - { - bool noChange = true; - StringBuilder changes = new StringBuilder(); - - for (int i = 0; i < files.Length; i++) - { - ConfigNode fileNode = getFileNode(shaConfigNode, files[i].url); - string fileSha = fileNode != null ? fileNode.GetValue("SHA") : null; - - if (fileNode == null) - continue; - - if (fileSha == null || filesSha[files[i].url] != fileSha) - { - changes.Append("Changed : " + fileNode.GetValue("filename") + ".cfg\n"); - noChange = false; - } - } - for (int i = 0; i < files.Length; i++) - { - ConfigNode fileNode = getFileNode(shaConfigNode, files[i].url); - - if (fileNode == null) - { - changes.Append("Added : " + files[i].url + ".cfg\n"); - noChange = false; - } - shaConfigNode.RemoveNode(fileNode); - } - foreach (ConfigNode fileNode in shaConfigNode.GetNodes()) - { - changes.Append("Deleted : " + fileNode.GetValue("filename") + ".cfg\n"); - noChange = false; - } - if (!noChange) - log("Changes :\n" + changes.ToString()); - return noChange; - } - - private ConfigNode getFileNode(ConfigNode shaConfigNode, string filename) - { - for (int i = 0; i < shaConfigNode.nodes.Count; i++) - { - ConfigNode file = shaConfigNode.nodes[i]; - if (file.name == "FILE" && file.GetValue("filename") == filename) - return file; - } - return null; - } - - - private void CreateCache() - { - ConfigNode shaConfigNode = new ConfigNode(); - shaConfigNode.AddValue("SHA", configSha); - shaConfigNode.AddValue("version", Assembly.GetExecutingAssembly().GetName().Version.ToString()); - shaConfigNode.AddValue("KSPVersion", Versioning.version_major + "." + Versioning.version_minor + "." + Versioning.Revision + "." + Versioning.BuildID); - ConfigNode filesSHANode = shaConfigNode.AddNode("FilesSHA"); - - ConfigNode cache = new ConfigNode(); - - cache.AddValue("patchedNodeCount", patchedNodeCount.ToString()); - - cache.AddValue("catEatenCount", catEatenCount.ToString()); - - foreach (UrlDir.UrlConfig config in GameDatabase.Instance.root.AllConfigs) - { - ConfigNode node = cache.AddNode("UrlConfig"); - node.AddValue("name", config.name); - node.AddValue("type", config.type); - node.AddValue("parentUrl", config.parent.url); - node.AddValue("url", config.url); - node.AddNode(config.config); - } - - foreach (var file in GameDatabase.Instance.root.AllConfigFiles) - { - // "/Physics" is the node we created manually to loads the PHYSIC config - if (file.url != "/Physics" && filesSha.ContainsKey(file.url)) - { - ConfigNode shaNode = filesSHANode.AddNode("FILE"); - shaNode.AddValue("filename", file.url); - shaNode.AddValue("SHA", filesSha[file.url]); - filesSha.Remove(file.url); - } - } - - log("Saving cache"); - - try - { - shaConfigNode.Save(shaPath); - } - catch (Exception e) - { - log("Exception while saving the sha\n" + e.ToString()); - } - try - { - cache.Save(cachePath); - return; - } - catch (NullReferenceException e) - { - log("NullReferenceException while saving the cache\n" + e.ToString()); - } - catch (Exception e) - { - log("Exception while saving the cache\n" + e.ToString()); - } - - try - { - log("An error occured while creating the cache. Deleting the cache files to avoid keeping a bad cache"); - if (File.Exists(cachePath)) - File.Delete(cachePath); - if (File.Exists(shaPath)) - File.Delete(shaPath); - } - catch (Exception e) - { - log("Exception while deleting the cache\n" + e.ToString()); - } - } - - private void SaveModdedTechTree() - { - UrlDir.UrlConfig[] configs = GameDatabase.Instance.GetConfigs("TechTree"); - - if (configs.Length == 0) - { - log("No TechTree node found. No custom TechTree will be saved"); - return; - } - - if (configs.Length > 1) - { - log(configs.Length + " TechTree node found. A patch may be wrong. Using the first one"); - } - - ConfigNode techNode = new ConfigNode("TechTree"); - techNode.AddNode(configs[0].config); - techNode.Save(techTreePath); - } - - private void LoadCache() - { - // Clear the config DB - foreach (UrlDir.UrlFile files in GameDatabase.Instance.root.AllConfigFiles) - { - files.configs.Clear(); - } - - // And then load all the cached configs - ConfigNode cache = ConfigNode.Load(cachePath); - - if (cache.HasValue("patchedNodeCount")) - int.TryParse(cache.GetValue("patchedNodeCount"), out patchedNodeCount); - - if (cache.HasValue("catEatenCount")) - int.TryParse(cache.GetValue("catEatenCount"), out catEatenCount); - - - // Create the fake file where we load the physic config cache - UrlDir gameDataDir = GameDatabase.Instance.root.AllDirectories.First(d => d.path.EndsWith("GameData") && d.name == "" && d.url == ""); - // need to use a file with a cfg extension to get the right fileType or you can't AddConfig on it - physicsUrlFile = new UrlDir.UrlFile(gameDataDir, new FileInfo(defaultPhysicsPath)); - gameDataDir.files.Add(physicsUrlFile); - - foreach (ConfigNode node in cache.nodes) - { - string name = node.GetValue("name"); - string type = node.GetValue("type"); - string parentUrl = node.GetValue("parentUrl"); - string url = node.GetValue("url"); - - UrlDir.UrlFile parent = GameDatabase.Instance.root.AllConfigFiles.FirstOrDefault(f => f.url == parentUrl); - if (parent != null) - { - parent.AddConfig(node.nodes[0]); - } - else - { - log("Parent null for " + parentUrl); - } - } - log("Cache Loaded"); - } - - private void StatusUpdate() - { - status = "ModuleManager: " + patchedNodeCount + " patch" + (patchedNodeCount != 1 ? "es" : "") + (useCache ? " loaded from cache" : " applied"); - - if (errorCount > 0) - status += ", found " + errorCount + " error" + (errorCount != 1 ? "s" : ""); - if (catEatenCount > 0) - status += ", " + catEatenCount + " patch" + (catEatenCount != 1 ? "es were" : " was") + " eaten by the Win64 cat"; - } - - #region Needs checking - - private void CheckNeeds(List excludePaths) - { - UrlDir.UrlConfig[] allConfigs = GameDatabase.Instance.root.AllConfigs.ToArray(); - - // Check the NEEDS parts first. - foreach (UrlDir.UrlConfig mod in allConfigs) - { - UrlDir.UrlConfig currentMod = mod; - try - { - string name; - if (IsPathInList(currentMod.url, excludePaths) && (ParseCommand(currentMod.type, out name) != Command.Insert)) - { - mod.parent.configs.Remove(currentMod); - catEatenCount++; - log("Deleting Node in file " + currentMod.parent.url + " subnode: " + currentMod.type + - " as it is set to be disabled on KSP Win64"); - continue; - } - - if (mod.config.name == null) - { - log("Error - Node in file " + currentMod.parent.url + " subnode: " + currentMod.type + - " has config.name == null"); - } - - if (currentMod.type.Contains(":NEEDS[")) - { - mod.parent.configs.Remove(currentMod); - string type = currentMod.type; - - if (!CheckNeeds(ref type)) - { - log("Deleting Node in file " + currentMod.parent.url + " subnode: " + currentMod.type + - " as it can't satisfy its NEEDS"); - needsUnsatisfiedCount++; - continue; - } - - ConfigNode copy = new ConfigNode(type); - ShallowCopy(currentMod.config, copy); - currentMod = new UrlDir.UrlConfig(currentMod.parent, copy); - mod.parent.configs.Add(currentMod); - } - - // Recursively check the contents - CheckNeeds(currentMod.config, currentMod.parent.url, new List()); - } - catch (Exception ex) - { - log("Exception while checking needs : " + currentMod.url + " with a type of " + currentMod.type + "\n" + ex); - log("Node is : " + PrettyConfig(currentMod)); - } - } - } - - private void CheckNeeds(ConfigNode subMod, string url, List path) - { - try - { - path.Add(subMod.name); - bool needsCopy = false; - ConfigNode copy = new ConfigNode(subMod.name); - for (int i = 0; i < subMod.values.Count; ++i) - { - ConfigNode.Value val = subMod.values[i]; - string valname = val.name; - try - { - if (CheckNeeds(ref valname)) - { - copy.AddValue(valname, val.value); - } - else - { - needsCopy = true; - log( - "Deleting value in file: " + url + " subnode: " + string.Join("/", path.ToArray()) + - " value: " + val.name + " = " + val.value + " as it can't satisfy its NEEDS"); - needsUnsatisfiedCount++; - } - } - catch (ArgumentOutOfRangeException e) - { - log("ArgumentOutOfRangeException in CheckNeeds for value \"" + val.name + "\"\n" + e); - throw; - } - catch (Exception e) - { - log("General Exception " + e.GetType().Name + " for value \"" + val.name + " = " + val.value + "\"\n" + e.ToString()); - throw; - } - } - - for (int i = 0; i < subMod.nodes.Count; ++i) - { - ConfigNode node = subMod.nodes[i]; - string nodeName = node.name; - - if (nodeName == null) - { - log("Error - Node in file " + url + " subnode: " + string.Join("/", path.ToArray()) + - " has config.name == null"); - } - - try - { - if (CheckNeeds(ref nodeName)) - { - node.name = nodeName; - CheckNeeds(node, url, path); - copy.AddNode(node); - } - else - { - needsCopy = true; - log( - "Deleting node in file: " + url + " subnode: " + string.Join("/", path.ToArray()) + "/" + - node.name + " as it can't satisfy its NEEDS"); - needsUnsatisfiedCount++; - } - } - catch (ArgumentOutOfRangeException e) - { - log("ArgumentOutOfRangeException in CheckNeeds for node \"" + node.name + "\"\n" + e); - throw; - } - catch (Exception e) - { - log("General Exception " + e.GetType().Name + " for node \"" + node.name + "\"\n " + e.ToString()); - throw; - } - } - - if (needsCopy) - ShallowCopy(copy, subMod); - } - finally - { - path.RemoveAt(path.Count - 1); - } - } - - /// - /// Returns true if needs are satisfied. - /// - private bool CheckNeeds(ref string name) - { - if (name == null) - return true; - - int idxStart = name.IndexOf(":NEEDS["); - if (idxStart < 0) - return true; - int idxEnd = name.IndexOf(']', idxStart + 7); - string needsString = name.Substring(idxStart + 7, idxEnd - idxStart - 7).ToUpper(); - - name = name.Substring(0, idxStart) + name.Substring(idxEnd + 1); - - // Check to see if all the needed dependencies are present. - foreach (string andDependencies in needsString.Split(',', '&')) - { - bool orMatch = false; - foreach (string orDependency in andDependencies.Split('|')) - { - if (orDependency.Length == 0) - continue; - - bool not = orDependency[0] == '!'; - string toFind = not ? orDependency.Substring(1) : orDependency; - bool found = mods.Contains(toFind, StringComparer.OrdinalIgnoreCase); - - if (not == !found) - { - orMatch = true; - break; - } - } - if (!orMatch) - return false; - } - - return true; - } - - private void PurgeUnused(List excludePaths) - { - foreach (UrlDir.UrlConfig mod in GameDatabase.Instance.root.AllConfigs.ToArray()) - { - string name = RemoveWS(mod.type); - - if (ParseCommand(name, out name) != Command.Insert) - mod.parent.configs.Remove(mod); - } - } - - #endregion Needs checking - - #region Applying Patches - - // Apply patch to all relevent nodes - public IEnumerator ApplyPatch(List excludePaths, string Stage) - { - log(Stage + (Stage == ":LEGACY" ? " (default) pass" : " pass")); - - activity = "ModuleManager " + Stage; - - UrlDir.UrlConfig[] allConfigs = GameDatabase.Instance.root.AllConfigs.ToArray(); - - float nextYield = Time.realtimeSinceStartup + yieldInterval; - - for (int modsIndex = 0; modsIndex < allConfigs.Length; modsIndex++) - { - UrlDir.UrlConfig mod = allConfigs[modsIndex]; - int lastErrorCount = errorCount; - try - { - string name = RemoveWS(mod.type); - string tmp; - Command cmd = ParseCommand(name, out tmp); - - if (cmd != Command.Insert) - { - if (!IsBracketBalanced(mod.type)) - { - log( - "Error - Skipping a patch with unbalanced square brackets or a space (replace them with a '?') :\n" + - mod.name + "\n"); - errorCount++; - - // And remove it so it's not tried anymore - mod.parent.configs.Remove(mod); - continue; - } - - // Ensure the stage is correct - string upperName = name.ToUpper(); - - int stageIdx = upperName.IndexOf(Stage); - if (stageIdx >= 0) - name = name.Substring(0, stageIdx) + name.Substring(stageIdx + Stage.Length); - else if ( - !((upperName.Contains(":FIRST") || Stage == ":LEGACY") - && !upperName.Contains(":BEFORE[") && !upperName.Contains(":FOR[") - && !upperName.Contains(":AFTER[") && !upperName.Contains(":FINAL"))) - continue; - - // TODO: do we want to ensure there's only one phase specifier? - - try - { - char[] sep = { '[', ']' }; - string condition = ""; - - if (upperName.Contains(":HAS[")) - { - int start = upperName.IndexOf(":HAS["); - condition = name.Substring(start + 5, name.LastIndexOf(']') - start - 5); - name = name.Substring(0, start); - } - - string[] splits = name.Split(sep, 3); - string[] patterns = splits.Length > 1 ? splits[1].Split(',', '|') : new string[] { null }; - string type = splits[0].Substring(1); - - foreach (UrlDir.UrlConfig url in GameDatabase.Instance.root.AllConfigs.ToArray()) - { - foreach (string pattern in patterns) - { - bool loop = false; - do - { - if (url.type == type && WildcardMatch(url.name, pattern) - && CheckConstraints(url.config, condition) && !IsPathInList(mod.url, excludePaths)) - { - nodeStack.Clear(); - switch (cmd) - { - case Command.Edit: - log("Applying node " + mod.url + " to " + url.url); - patchedNodeCount++; - url.config = ModifyNode(url.config, mod.config); - break; - - case Command.Copy: - ConfigNode clone = ModifyNode(url.config, mod.config); - if (url.config.name != mod.name) - { - log("Copying Node " + url.config.name + " into " + clone.name); - url.parent.configs.Add(new UrlDir.UrlConfig(url.parent, clone)); - } - else - { - errorCount++; - log("Error - Error while processing " + mod.config.name + - " the copy needs to have a different name than the parent (use @name = xxx)"); - } - break; - - case Command.Delete: - log("Deleting Node " + url.config.name); - url.parent.configs.Remove(url); - break; - - case Command.Replace: - - // TODO: do something sensible here. - break; - - case Command.Create: - - // TODO: something similar to above - break; - } - // When this special node is found then try to apply the patch once more on the same NODE - if (mod.config.HasNode("MM_PATCH_LOOP")) - { - log("Looping on " + mod.url + " to " + url.url); - loop = true; - } - } - else - { - loop = false; - } - } while (loop); - - } - } - } - finally - { - // The patch was either run or has failed, in any case let's remove it from the database - appliedPatchCount++; - mod.parent.configs.Remove(mod); - } - } - } - catch (Exception e) - { - log("Exception while processing node : " + mod.url + "\n" + e); - log(PrettyConfig(mod)); - mod.parent.configs.Remove(mod); - } - finally - { - if (lastErrorCount < errorCount) - addErrorFiles(mod.parent, errorCount - lastErrorCount); - } - if (nextYield < Time.realtimeSinceStartup) - { - nextYield = Time.realtimeSinceStartup + yieldInterval; - yield return null; - } - } - } - - // Name is group 1, index is group 2, vector related filed is group 3, vector separator is group 4, operator is group 5 - private static Regex parseValue = new Regex(@"([\w\&\-\.\?\*]*)(?:,(-?[0-9\*]+))?(?:\[((?:[0-9\*]+)+)(?:,(.))?\])?(?:\s([+\-*/^!]))?"); - - // Path is group 1, operator is group 5 - private static Regex parseAssign = new Regex(@"(.*)(?:\s)+([+\-*/^!])?"); - - // ModifyNode applies the ConfigNode mod as a 'patch' to ConfigNode original, then returns the patched ConfigNode. - // it uses FindConfigNodeIn(src, nodeType, nodeName, nodeTag) to recurse. - public ConfigNode ModifyNode(ConfigNode original, ConfigNode mod) - { - ConfigNode newNode = DeepCopy(original); - - if (nodeStack.Count == 0) - topNode = newNode; - - nodeStack.Push(newNode); - - #region Values - - string vals = "[ModuleManager] modding values"; - foreach (ConfigNode.Value modVal in mod.values) - { - vals += "\n " + modVal.name + "= " + modVal.value; - - string valName; - Command cmd = ParseCommand(modVal.name, out valName); - - if (cmd == Command.Special) - { - Match assignMatch = parseAssign.Match(valName); - if (!assignMatch.Success) - { - log("Error - Cannot parse value assigning command: " + valName); - errorCount++; - continue; - } - - valName = assignMatch.Groups[1].Value; - - ConfigNode.Value val = RecurseVariableSearch(valName, mod); - - if (val == null) - { - log("Error - Cannot find value assigning command: " + valName); - errorCount++; - continue; - } - - if (assignMatch.Groups[2].Success) - { - double os, s; - if (double.TryParse(modVal.value, out s) && double.TryParse(val.value, out os)) - { - switch (assignMatch.Groups[2].Value[0]) - { - case '*': - val.value = (os * s).ToString(); - break; - - case '/': - val.value = (os / s).ToString(); - break; - - case '+': - val.value = (os + s).ToString(); - break; - - case '-': - val.value = (os - s).ToString(); - break; - - case '!': - val.value = Math.Pow(os, s).ToString(); - break; - } - } - } - else - { - val.value = modVal.value; - } - continue; - } - - Match match = parseValue.Match(valName); - if (!match.Success) - { - log("Error - Cannot parse value modifying command: " + valName); - errorCount++; - continue; - } - - // Get the bits and pieces from the regexp - valName = match.Groups[1].Value; - - // Get a position for editing a vector - int position = 0; - bool isPosStar = false; - if (match.Groups[3].Success) - { - if (match.Groups[3].Value == "*") - isPosStar = true; - else if (!int.TryParse(match.Groups[3].Value, out position)) - { - Debug.LogError("Error - Unable to parse number as number. Very odd."); - errorCount++; - continue; - } - } - char seperator = ','; - if (match.Groups[4].Success) - { - seperator = match.Groups[4].Value[0]; - } - - // In this case insert the value at position index (with the same node names) - int index = 0; - bool isStar = false; - if (match.Groups[2].Success) - { - if (match.Groups[2].Value == "*") - isStar = true; - // can have "node,n *" (for *= ect) - else if (!int.TryParse(match.Groups[2].Value, out index)) - { - Debug.LogError("Error - Unable to parse number as number. Very odd."); - errorCount++; - continue; - } - } - - char op = ' '; - if (match.Groups[5].Success) - op = match.Groups[5].Value[0]; - - string varValue; - switch (cmd) - { - case Command.Insert: - if (match.Groups[5].Success) - { - log("Error - Cannot use operators with insert value: " + mod.name); - errorCount++; - } - else - { - // Insert at the end by default - varValue = ProcessVariableSearch(modVal.value, newNode); - if (varValue != null) - InsertValue(newNode, match.Groups[2].Success ? index : int.MaxValue, valName, varValue); - else - { - log("Error - Cannot parse variable search when inserting new key " + valName + " = " + - modVal.value); - errorCount++; - } - } - break; - - case Command.Replace: - if (match.Groups[2].Success || match.Groups[5].Success || valName.Contains('*') - || valName.Contains('?')) - { - if (match.Groups[2].Success) - log("Error - Cannot use index with replace (%) value: " + mod.name); - if (match.Groups[5].Success) - log("Error - Cannot use operators with replace (%) value: " + mod.name); - if (valName.Contains('*') || valName.Contains('?')) - log("Error - Cannot use wildcards (* or ?) with replace (%) value: " + mod.name); - errorCount++; - } - else - { - varValue = ProcessVariableSearch(modVal.value, newNode); - if (varValue != null) - { - newNode.RemoveValues(valName); - newNode.AddValue(valName, varValue); - } - else - { - log("Error - Cannot parse variable search when replacing (%) key " + valName + " = " + - modVal.value); - errorCount++; - } - } - break; - - case Command.Edit: - case Command.Copy: - - // Format is @key = value or @key *= value or @key += value or @key -= value - // or @key,index = value or @key,index *= value or @key,index += value or @key,index -= value - - while (index < newNode.values.Count) - { - varValue = ProcessVariableSearch(modVal.value, newNode); - - if (varValue != null) - { - ConfigNode.Value origVal; - string value = FindAndReplaceValue(mod, ref valName, varValue, newNode, op, index, - out origVal, match.Groups[3].Success, position, isPosStar, seperator); - - if (value != null) - { - if (origVal.value != value) - vals += ": " + origVal.value + " -> " + value; - - if (cmd != Command.Copy) - origVal.value = value; - else - newNode.AddValue(valName, value); - } - } - else - { - log("Error - Cannot parse variable search when editing key " + valName + " = " + modVal.value); - errorCount++; - } - - if (isStar) index++; - else break; - } - break; - - case Command.Delete: - if (match.Groups[5].Success) - { - log("Error - Cannot use operators with delete (- or !) value: " + mod.name); - errorCount++; - } - else if (match.Groups[2].Success) - { - while (index < newNode.values.Count) - { - // If there is an index, use it. - ConfigNode.Value v = FindValueIn(newNode, valName, index); - if (v != null) - newNode.values.Remove(v); - if (isStar) index++; - else break; - } - } - else if (valName.Contains('*') || valName.Contains('?')) - { - // Delete all matching wildcard - ConfigNode.Value last = null; - while (true) - { - ConfigNode.Value v = FindValueIn(newNode, valName, index++); - if (v == last) - break; - last = v; - newNode.values.Remove(v); - } - } - else - { - // Default is to delete ALL values that match. (backwards compatibility) - newNode.RemoveValues(valName); - } - break; - - case Command.Rename: - if (nodeStack.Count == 1) - { - log("Error - Renaming nodes does not work on top nodes"); - errorCount++; - break; - } - newNode.name = modVal.value; - break; - - case Command.Create: - if (match.Groups[2].Success || match.Groups[5].Success || valName.Contains('*') - || valName.Contains('?')) - { - if (match.Groups[2].Success) - log("Error - Cannot use index with create (&) value: " + mod.name); - if (match.Groups[5].Success) - log("Error - Cannot use operators with create (&) value: " + mod.name); - if (valName.Contains('*') || valName.Contains('?')) - log("Error - Cannot use wildcards (* or ?) with create (&) value: " + mod.name); - errorCount++; - } - else - { - varValue = ProcessVariableSearch(modVal.value, newNode); - if (varValue != null) - { - if (!newNode.HasValue(valName)) - newNode.AddValue(valName, varValue); - } - else - { - log("Error - Cannot parse variable search when replacing (%) key " + valName + " = " + - modVal.value); - errorCount++; - } - } - break; - } - } - //log(vals); - - #endregion Values - - #region Nodes - - foreach (ConfigNode subMod in mod.nodes) - { - subMod.name = RemoveWS(subMod.name); - - if (!IsBracketBalanced(subMod.name)) - { - log( - "Error - Skipping a patch subnode with unbalanced square brackets or a space (replace them with a '?') in " - + mod.name + " : \n" + subMod.name + "\n"); - errorCount++; - continue; - } - - string subName = subMod.name; - string tmp; - Command command = ParseCommand(subName, out tmp); - - if (command == Command.Insert) - { - ConfigNode newSubMod = new ConfigNode(subMod.name); - newSubMod = ModifyNode(newSubMod, subMod); - subName = newSubMod.name; - int index; - if (subName.Contains(",") && int.TryParse(subName.Split(',')[1], out index)) - { - // In this case insert the node at position index (with the same node names) - newSubMod.name = subName.Split(',')[0]; - InsertNode(newNode, newSubMod, index); - } - else - { - newNode.AddNode(newSubMod); - } - } - else if (command == Command.Paste) - { - //int start = subName.IndexOf('['); - //int end = subName.LastIndexOf(']'); - //if (start == -1 || end == -1 || end - start < 1) - //{ - // log("Pasting a node require a [path] to the node to paste" + mod.name + " : \n" + subMod.name + "\n"); - // errorCount++; - // continue; - //} - - //string newName = subName.Substring(0, start); - //string path = subName.Substring(start + 1, end - start - 1); - - ConfigNode toPaste = RecurseNodeSearch(subName.Substring(1), nodeStack.Peek()); - - if (toPaste == null) - { - log("Error - Can not find the node to paste in " + mod.name + " : " + subMod.name + "\n"); - errorCount++; - continue; - } - - ConfigNode newSubMod = new ConfigNode(toPaste.name); - newSubMod = ModifyNode(newSubMod, toPaste); - int index; - if (subName.LastIndexOf(",") > 0 && int.TryParse(subName.Substring(subName.LastIndexOf(",") + 1), out index)) - { - // In this case insert the node at position index - InsertNode(newNode, newSubMod, index); - } - else - newNode.AddNode(newSubMod); - } - else - { - string constraints = ""; - string tag = ""; - string nodeType, nodeName; - int index = 0; - string msg = ""; - - List subNodes = new List(); - - // three ways to specify: - // NODE,n will match the nth node (NODE is the same as NODE,0) - // NODE,* will match ALL nodes - // NODE:HAS[condition] will match ALL nodes with condition - if (subName.Contains(":HAS[")) - { - int start = subName.IndexOf(":HAS["); - constraints = subName.Substring(start + 5, subName.LastIndexOf(']') - start - 5); - subName = subName.Substring(0, start); - } - - if (subName.Contains(",")) - { - tag = subName.Split(',')[1]; - subName = subName.Split(',')[0]; - int.TryParse(tag, out index); - } - - if (subName.Contains("[")) - { - // format @NODETYPE[Name] {...} - // or @NODETYPE[Name, index] {...} - nodeType = subName.Substring(1).Split('[')[0]; - nodeName = subName.Split('[')[1].Replace("]", ""); - } - else - { - // format @NODETYPE {...} or ! instead of @ - nodeType = subName.Substring(1); - nodeName = null; - } - - if (tag == "*" || constraints.Length > 0) - { - // get ALL nodes - if (command == Command.Replace) - msg += " cannot wildcard a % node: " + subMod.name + "\n"; - else - { - ConfigNode n, last = null; - while (true) - { - n = FindConfigNodeIn(newNode, nodeType, nodeName, index++); - if (n == last || n == null) - break; - if (CheckConstraints(n, constraints)) - subNodes.Add(n); - last = n; - } - } - } - else - { - // just get one node - ConfigNode n = FindConfigNodeIn(newNode, nodeType, nodeName, index); - if (n != null) - subNodes.Add(n); - } - - if (command == Command.Replace) - { - // if the original exists modify it - if (subNodes.Count > 0) - { - msg += " Applying subnode " + subMod.name + "\n"; - ConfigNode newSubNode = ModifyNode(subNodes[0], subMod); - subNodes[0].ClearData(); - newSubNode.CopyTo(subNodes[0], newSubNode.name); - } - else - { - // if not add the mod node without the % in its name - msg += " Adding subnode " + subMod.name + "\n"; - - ConfigNode copy = new ConfigNode(nodeType); - - if (nodeName != null) - copy.AddValue("name", nodeName); - - ConfigNode newSubNode = ModifyNode(copy, subMod); - newNode.nodes.Add(newSubNode); - } - } - else if (command == Command.Create) - { - if (subNodes.Count == 0) - { - msg += " Adding subnode " + subMod.name + "\n"; - - ConfigNode copy = new ConfigNode(nodeType); - - if (nodeName != null) - copy.AddValue("name", nodeName); - - ConfigNode newSubNode = ModifyNode(copy, subMod); - newNode.nodes.Add(newSubNode); - } - } - else - { - // find each original subnode to modify, modify it and add the modified. - if (subNodes.Count == 0) // no nodes to modify! - msg += " Could not find node(s) to modify: " + subMod.name + "\n"; - - foreach (ConfigNode subNode in subNodes) - { - msg += " Applying subnode " + subMod.name + "\n"; - ConfigNode newSubNode; - switch (command) - { - case Command.Edit: - - // Edit in place - newSubNode = ModifyNode(subNode, subMod); - subNode.ClearData(); - newSubNode.CopyTo(subNode, newSubNode.name); - break; - - case Command.Delete: - - // Delete the node - newNode.nodes.Remove(subNode); - break; - - case Command.Copy: - - // Copy the node - newSubNode = ModifyNode(subNode, subMod); - newNode.nodes.Add(newSubNode); - break; - } - } - } - - //print(msg); - } - } - - #endregion Nodes - - nodeStack.Pop(); - - return newNode; - } - - - // Search for a ConfigNode by a path alike string - private ConfigNode RecurseNodeSearch(string path, ConfigNode currentNode) - { - //log("Path : \"" + path + "\""); - - if (path[0] == '/') - { - currentNode = topNode; - path = path.Substring(1); - } - - int nextSep = path.IndexOf('/'); - - bool root = (path[0] == '@'); - int shift = root ? 1 : 0; - string subName = (nextSep != -1) ? path.Substring(shift, nextSep - shift) : path.Substring(shift); - string nodeType, nodeName; - string constraint = ""; - - int index = 0; - if (subName.Contains(":HAS[")) - { - int start = subName.IndexOf(":HAS["); - constraint = subName.Substring(start + 5, subName.LastIndexOf(']') - start - 5); - subName = subName.Substring(0, start); - } - else if (subName.Contains(",")) - { - string tag = subName.Split(',')[1]; - subName = subName.Split(',')[0]; - int.TryParse(tag, out index); - } - - if (subName.Contains("[")) - { - // NODETYPE[Name] - nodeType = subName.Split('[')[0]; - nodeName = subName.Split('[')[1].Replace("]", ""); - } - else - { - // NODETYPE - nodeType = subName; - nodeName = null; - } - - // ../XXXXX - if (path.StartsWith("../")) - { - if (nodeStack.Count == 1) - return null; - ConfigNode result; - ConfigNode top = nodeStack.Pop(); - try - { - result = RecurseNodeSearch(path.Substring(3), nodeStack.Peek()); - } - finally - { - nodeStack.Push(top); - } - return result; - } - - //log("nextSep : \"" + nextSep + " \" root : \"" + root + " \" nodeType : \"" + nodeType + "\" nodeName : \"" + nodeName + "\""); - - // @XXXXX - if (root) - { - ConfigNode[] list = GameDatabase.Instance.GetConfigNodes(nodeType); - if (list.Length == 0) - { - log("Can't find nodeType:" + nodeType); - return null; - } - - if (nodeName == null) - { - currentNode = list[0]; - } - else - { - for (int i = 0; i < list.Length; i++) - { - if (list[i].HasValue("name") && WildcardMatch(list[i].GetValue("name"), nodeName)) - { - currentNode = list[i]; - break; - } - } - } - } - else - { - if (constraint.Length > 0) - { - // get the first one matching - ConfigNode n, last = null; - while (true) - { - n = FindConfigNodeIn(currentNode, nodeType, nodeName, index++); - if (n == last || n == null) - { - currentNode = null; - break; - } - if (CheckConstraints(n, constraint)) - { - currentNode = n; - break; - } - last = n; - } - } - else - { - // just get one node - currentNode = FindConfigNodeIn(currentNode, nodeType, nodeName, index); - } - } - - // XXXXXX/ - if (nextSep > 0 && currentNode != null) - { - path = path.Substring(nextSep + 1); - //log("NewPath : \"" + path + "\""); - return RecurseNodeSearch(path, currentNode); - } - - return currentNode; - } - - // KeyName is group 1, index is group 2, value index is group 3, value separator is group 4 - private static readonly Regex parseVarKey = new Regex(@"([\w\&\-\.]+)(?:,((?:[0-9]+)+))?(?:\[((?:[0-9]+)+)(?:,(.))?\])?"); - - // Search for a value by a path alike string - private static ConfigNode.Value RecurseVariableSearch(string path, ConfigNode currentNode) - { - //log("path:" + path); - if (path[0] == '/') - return RecurseVariableSearch(path.Substring(1), topNode); - int nextSep = path.IndexOf('/'); - - // make sure we don't stop on a ",/" which would be a value separator - // it's a hack that should be replaced with a proper regex for the whole node search - while (nextSep > 0 && path[nextSep - 1] == ',') - nextSep = path.IndexOf('/', nextSep + 1); - - if (path[0] == '@') - { - if (nextSep < 2) - return null; - - string subName = path.Substring(1, nextSep - 1); - string nodeType, nodeName; - ConfigNode target = null; - - if (subName.Contains("[")) - { - // @NODETYPE[Name]/ - nodeType = subName.Split('[')[0]; - nodeName = subName.Split('[')[1].Replace("]", ""); - } - else - { - // @NODETYPE/ - nodeType = subName; - nodeName = string.Empty; - } - - ConfigNode[] list = GameDatabase.Instance.GetConfigNodes(nodeType); - if (list.Length == 0) - { - log("Can't find nodeType:" + nodeType); - return null; - } - - if (nodeName == string.Empty) - { - target = list[0]; - } - else - { - for (int i = 0; i < list.Length; i++) - { - if (list[i].HasValue("name") && WildcardMatch(list[i].GetValue("name"), nodeName)) - { - target = list[i]; - break; - } - } - } - return target != null ? RecurseVariableSearch(path.Substring(nextSep + 1), target) : null; - } - if (path.StartsWith("../")) - { - if (nodeStack.Count == 1) - return null; - ConfigNode.Value result; - ConfigNode top = nodeStack.Pop(); - try - { - result = RecurseVariableSearch(path.Substring(3), nodeStack.Peek()); - } - finally - { - nodeStack.Push(top); - } - return result; - } - - // Node search - if (nextSep > 0 && path[nextSep - 1] != ',') - { - // Big case of code duplication here ... - // TODO : replace with a regex - - string subName = path.Substring(0, nextSep); - string constraint = ""; - string nodeType, nodeName; - int index = 0; - if (subName.Contains(":HAS[")) - { - int start = subName.IndexOf(":HAS["); - constraint = subName.Substring(start + 5, subName.LastIndexOf(']') - start - 5); - subName = subName.Substring(0, start); - } - else if (subName.Contains(",")) - { - string tag = subName.Split(',')[1]; - subName = subName.Split(',')[0]; - int.TryParse(tag, out index); - } - - if (subName.Contains("[")) - { - // format NODETYPE[Name] {...} - // or NODETYPE[Name, index] {...} - nodeType = subName.Split('[')[0]; - nodeName = subName.Split('[')[1].Replace("]", ""); - } - else - { - // format NODETYPE {...} - nodeType = subName; - nodeName = null; - } - - if (constraint.Length > 0) - { - // get the first one matching - ConfigNode n, last = null; - while (true) - { - n = FindConfigNodeIn(currentNode, nodeType, nodeName, index++); - if (n == last || n == null) - break; - if (CheckConstraints(n, constraint)) - return RecurseVariableSearch(path.Substring(nextSep + 1), n); - last = n; - } - return null; - } - else - { - // just get one node - ConfigNode n = FindConfigNodeIn(currentNode, nodeType, nodeName, index); - if (n != null) - return RecurseVariableSearch(path.Substring(nextSep + 1), n); - return null; - } - } - - // Value search - - Match match = parseVarKey.Match(path); - if (!match.Success) - { - log("Cannot parse variable search command: " + path); - return null; - } - - string valName = match.Groups[1].Value; - - int idx = 0; - if (match.Groups[2].Success) - int.TryParse(match.Groups[2].Value, out idx); - - ConfigNode.Value cVal = FindValueIn(currentNode, valName, idx); - if (cVal == null) - { - log("Cannot find key " + valName + " in " + currentNode.name); - return null; - } - - if (match.Groups[3].Success) - { - ConfigNode.Value newVal = new ConfigNode.Value(cVal.name, cVal.value); - int splitIdx = 0; - int.TryParse(match.Groups[3].Value, out splitIdx); - - char sep = ','; - if (match.Groups[4].Success) - sep = match.Groups[4].Value[0]; - string[] split = newVal.value.Split(sep); - if (splitIdx < split.Length) - newVal.value = split[splitIdx]; - else - newVal.value = ""; - return newVal; - } - return cVal; - } - - private static string ProcessVariableSearch(string value, ConfigNode node) - { - // value = #xxxx$yyyyy$zzzzz$aaaa$bbbb - // There is 2 or more '$' - if (value.Length > 0 && value[0] == '#' && value.IndexOf('$') != -1 && value.IndexOf('$') != value.LastIndexOf('$')) - { - //log("variable search input : =\"" + value + "\""); - string[] split = value.Split('$'); - - if (split.Length % 2 != 1) - return null; - - StringBuilder builder = new StringBuilder(); - builder.Append(split[0].Substring(1)); - - for (int i = 1; i < split.Length - 1; i = i + 2) - { - ConfigNode.Value result = RecurseVariableSearch(split[i], node); - if (result == null || result.value == null) - return null; - builder.Append(result.value); - builder.Append(split[i + 1]); - } - value = builder.ToString(); - //log("variable search output : =\"" + value + "\""); - } - return value; - } - - private string FindAndReplaceValue( - ConfigNode mod, - ref string valName, - string value, - ConfigNode newNode, - char op, - int index, - out ConfigNode.Value origVal, - bool hasPosIndex = false, - int posIndex = 0, - bool hasPosStar = false, - char seperator = ',') - { - origVal = FindValueIn(newNode, valName, index); - if (origVal == null) - return null; - string oValue = origVal.value; - - string[] strArray = new string[] { oValue }; - if (hasPosIndex) - { - strArray = oValue.Split(new char[] { seperator }, StringSplitOptions.RemoveEmptyEntries); - if (posIndex >= strArray.Length) - { - log("Invalid Vector Index!"); - errorCount++; - return null; - } - } - string backupValue = value; - while (posIndex < strArray.Length) - { - value = backupValue; - oValue = strArray[posIndex]; - if (op != ' ') - { - double s, os; - if (op == '^') - { - try - { - string[] split = value.Split(value[0]); - - Regex replace; - if (regexCache.ContainsKey(split[1])) - replace = regexCache[split[1]]; - else - { - replace = new Regex(split[1], RegexOptions.None); - regexCache.Add(split[1], replace); - } - - value = replace.Replace(oValue, split[2]); - } - catch (Exception ex) - { - log("Error - Failed to do a regexp replacement: " + mod.name + " : original value=\"" + oValue + - "\" regexp=\"" + value + - "\" \nNote - to use regexp, the first char is used to subdivide the string (much like sed)\n" + - ex); - errorCount++; - return null; - } - } - else if (double.TryParse(value, out s) && double.TryParse(oValue, out os)) - { - switch (op) - { - case '*': - value = (os * s).ToString(); - break; - - case '/': - value = (os / s).ToString(); - break; - - case '+': - value = (os + s).ToString(); - break; - - case '-': - value = (os - s).ToString(); - break; - - case '!': - value = Math.Pow(os, s).ToString(); - break; - } - } - else - { - log("Error - Failed to do a maths replacement: " + mod.name + " : original value=\"" + oValue + - "\" operator=" + op + " mod value=\"" + value + "\""); - errorCount++; - return null; - } - } - strArray[posIndex] = value; - if (hasPosStar) posIndex++; - else break; - } - value = String.Join(new string(seperator, 1), strArray); - return value; - } - - #endregion Applying Patches - - #region Command Parsing - - private enum Command - { - Insert, - - Delete, - - Edit, - - Replace, - - Copy, - - Rename, - - Paste, - - Special, - - Create - } - - private static Command ParseCommand(string name, out string valueName) - { - if (name.Length == 0) - { - valueName = string.Empty; - return Command.Insert; - } - Command ret; - switch (name[0]) - { - case '@': - ret = Command.Edit; - break; - - case '%': - ret = Command.Replace; - break; - - case '-': - case '!': - ret = Command.Delete; - break; - - case '+': - case '$': - ret = Command.Copy; - break; - - case '|': - ret = Command.Rename; - break; - - case '#': - ret = Command.Paste; - break; - - case '*': - ret = Command.Special; - break; - - case '&': - ret = Command.Create; - break; - - default: - valueName = name; - return Command.Insert; - } - valueName = name.Substring(1); - return ret; - } - - #endregion Command Parsing - - #region Sanity checking & Utility functions - - public static bool IsBracketBalanced(string str) - { - Stack stack = new Stack(); - - char c; - for (int i = 0; i < str.Length; i++) - { - c = str[i]; - if (c == '[') - stack.Push(c); - else if (c == ']') - { - if (stack.Count == 0) - return false; - if (stack.Peek() == '[') - stack.Pop(); - else - return false; - } - } - return stack.Count == 0; - } - - public static string RemoveWS(string withWhite) - { - // Removes ALL whitespace of a string. - return new string(withWhite.ToCharArray().Where(c => !Char.IsWhiteSpace(c)).ToArray()); - } - - public bool IsPathInList(string modPath, List pathList) - { - return pathList.Any(modPath.StartsWith); - } - - #endregion Sanity checking & Utility functions - - #region Condition checking - - // Split condiction while not getting lost in embeded brackets - public static List SplitConstraints(string condition) - { - condition = RemoveWS(condition) + ","; - List conditions = new List(); - int start = 0; - int level = 0; - for (int end = 0; end < condition.Length; end++) - { - if ((condition[end] == ',' || condition[end] == '&') && level == 0) - { - conditions.Add(condition.Substring(start, end - start)); - start = end + 1; - } - else if (condition[end] == '[') - level++; - else if (condition[end] == ']') - level--; - } - return conditions; - } - - public static bool CheckConstraints(ConfigNode node, string constraints) - { - constraints = RemoveWS(constraints); - if (constraints.Length == 0) - return true; - - List constraintList = SplitConstraints(constraints); - - if (constraintList.Count == 1) - { - constraints = constraintList[0]; - - string remainingConstraints = ""; - if (constraints.Contains("HAS[")) - { - int start = constraints.IndexOf("HAS[") + 4; - remainingConstraints = constraints.Substring(start, constraintList[0].LastIndexOf(']') - start); - constraints = constraints.Substring(0, start - 5); - } - - char[] sep = { '[', ']' }; - string[] splits = constraints.Split(sep, 3); - string type = splits[0].Substring(1); - string name = splits.Length > 1 ? splits[1] : null; - - switch (constraints[0]) - { - case '@': - case '!': - - // @MODULE[ModuleAlternator] or !MODULE[ModuleAlternator] - bool not = (constraints[0] == '!'); - - bool any = false; - int index = 0; - ConfigNode last = null; - while (true) - { - ConfigNode subNode = FindConfigNodeIn(node, type, name, index++); - if (subNode == last || subNode == null) - break; - any = any || CheckConstraints(subNode, remainingConstraints); - last = subNode; - } - if (last != null) - return not ^ any; - - return not ^ false; - - case '#': - - // #module[Winglet] - if (node.HasValue(type) && WildcardMatchValues(node, type, name)) - return CheckConstraints(node, remainingConstraints); - return false; - - case '~': - - // ~breakingForce[] breakingForce is not present - // or: ~breakingForce[100] will be true if it's present but not 100, too. - if (name == "" && node.HasValue(type)) - return false; - if (name != "" && WildcardMatchValues(node, type, name)) - return false; - return CheckConstraints(node, remainingConstraints); - - default: - return false; - } - } - return constraintList.TrueForAll(c => CheckConstraints(node, c)); - } - - public static bool WildcardMatchValues(ConfigNode node, string type, string value) - { - double val = 0; - bool compare = value.Length > 1 && (value[0] == '<' || value[0] == '>'); - compare = compare && Double.TryParse(value.Substring(1), out val); - - string[] values = node.GetValues(type); - for (int i = 0; i < values.Length; i++) - { - if (!compare && WildcardMatch(values[i], value)) - return true; - - double val2; - if (compare && Double.TryParse(values[i], out val2) - && ((value[0] == '<' && val2 < val) || (value[0] == '>' && val2 > val))) - { - return true; - } - } - return false; - } - - public static bool WildcardMatch(string s, string wildcard) - { - if (wildcard == null) - return true; - string pattern = "^" + Regex.Escape(wildcard).Replace(@"\*", ".*").Replace(@"\?", ".") + "$"; - - Regex regex; - if (!regexCache.TryGetValue(pattern, out regex)) - { - regex = new Regex(pattern); - regexCache.Add(pattern, regex); - } - return regex.IsMatch(s); - } - - #endregion Condition checking - - #region Config Node Utilities - - private static void InsertNode(ConfigNode newNode, ConfigNode subMod, int index) - { - string modName = subMod.name; - - ConfigNode[] oldValues = newNode.GetNodes(modName); - if (index < oldValues.Length) - { - newNode.RemoveNodes(modName); - int i = 0; - for (; i < index; ++i) - newNode.AddNode(oldValues[i]); - newNode.AddNode(subMod); - for (; i < oldValues.Length; ++i) - newNode.AddNode(oldValues[i]); - } - else - newNode.AddNode(subMod); - } - - private static void InsertValue(ConfigNode newNode, int index, string name, string value) - { - string[] oldValues = newNode.GetValues(name); - if (index < oldValues.Length) - { - newNode.RemoveValues(name); - int i = 0; - for (; i < index; ++i) - newNode.AddValue(name, oldValues[i]); - newNode.AddValue(name, value); - for (; i < oldValues.Length; ++i) - newNode.AddValue(name, oldValues[i]); - return; - } - newNode.AddValue(name, value); - } - - private static void ShallowCopy(ConfigNode from, ConfigNode to) - { - to.ClearData(); - foreach (ConfigNode.Value value in from.values) - to.values.Add(value); - foreach (ConfigNode node in from.nodes) - to.nodes.Add(node); - } - - private static ConfigNode DeepCopy(ConfigNode from) - { - ConfigNode to = new ConfigNode(from.name); - foreach (ConfigNode.Value value in from.values) - to.AddValue(value.name, value.value); - foreach (ConfigNode node in from.nodes) - { - ConfigNode newNode = DeepCopy(node); - to.nodes.Add(newNode); - } - return to; - } - - private string PrettyConfig(UrlDir.UrlConfig config) - { - StringBuilder sb = new StringBuilder(); - sb.AppendFormat("{0}[{1}]\n", config.type ?? "NULL", config.name ?? "NULL"); - try - { - if (config.config != null) - { - PrettyConfig(config.config, ref sb, " "); - } - else - { - sb.Append("NULL\n"); - } - sb.Append("\n"); - } - catch (Exception e) - { - log("PrettyConfig Exception " + e); - } - return sb.ToString(); - } - - private void PrettyConfig(ConfigNode node, ref StringBuilder sb, string indent) - { - sb.AppendFormat("{0}{1}\n{2}{{\n", indent, node.name ?? "NULL", indent); - string newindent = indent + " "; - if (node.values != null) - { - foreach (ConfigNode.Value value in node.values) - { - if (value != null) - { - try - { - sb.AppendFormat("{0}{1} = {2}\n", newindent, value.name ?? "null", value.value ?? "null"); - } - catch (Exception) - { - log("value.name.Length=" + value.name.Length); - log("value.name.IsNullOrEmpty=" + string.IsNullOrEmpty(value.name)); - log("n " + value.name); - log("v " + value.value); - throw; - } - } - else - { - sb.AppendFormat("{0} Null value\n", newindent); - } - } - } - else - { - sb.AppendFormat("{0} Null values\n", newindent); - } - if (node.nodes != null) - { - foreach (ConfigNode subnode in node.nodes) - { - if (subnode != null) - { - PrettyConfig(subnode, ref sb, newindent); - } - else - { - sb.AppendFormat("{0} Null Subnode\n", newindent); - } - } - } - else - { - sb.AppendFormat("{0} Null nodes\n", newindent); - } - sb.AppendFormat("{0}}}\n", indent); - } - - //FindConfigNodeIn finds and returns a ConfigNode in src of type nodeType. - //If nodeName is not null, it will only find a node of type nodeType with the value name=nodeName. - //If nodeTag is not null, it will only find a node of type nodeType with the value name=nodeName and tag=nodeTag. - public static ConfigNode FindConfigNodeIn( - ConfigNode src, - string nodeType, - string nodeName = null, - int index = 0) - { - ConfigNode[] nodes = src.GetNodes(nodeType); - if (nodes.Length == 0) - return null; - if (nodeName == null) - { - if (index >= 0) - return nodes[Math.Min(index, nodes.Length - 1)]; - return nodes[Math.Max(0, nodes.Length + index)]; - } - ConfigNode last = null; - if (index >= 0) - { - for (int i = 0; i < nodes.Length; ++i) - { - if (nodes[i].HasValue("name") && WildcardMatch(nodes[i].GetValue("name"), nodeName)) - { - last = nodes[i]; - if (--index < 0) - return last; - } - } - return last; - } - for (int i = nodes.Length - 1; i >= 0; --i) - { - if (nodes[i].HasValue("name") && WildcardMatch(nodes[i].GetValue("name"), nodeName)) - { - last = nodes[i]; - if (++index >= 0) - return last; - } - } - return last; - } - - private static ConfigNode.Value FindValueIn(ConfigNode newNode, string valName, int index) - { - ConfigNode.Value v = null; - for (int i = 0; i < newNode.values.Count; ++i) - { - if (WildcardMatch(newNode.values[i].name, valName)) - { - v = newNode.values[i]; - if (--index < 0) - return v; - } - } - return v; - } - - private static bool CompareRecursive(ConfigNode expectNode, ConfigNode gotNode) - { - if (expectNode.values.Count != gotNode.values.Count || expectNode.nodes.Count != gotNode.nodes.Count) - return false; - for (int i = 0; i < expectNode.values.Count; ++i) - { - ConfigNode.Value eVal = expectNode.values[i]; - ConfigNode.Value gVal = gotNode.values[i]; - if (eVal.name != gVal.name || eVal.value != gVal.value) - return false; - } - for (int i = 0; i < expectNode.nodes.Count; ++i) - { - ConfigNode eNode = expectNode.nodes[i]; - ConfigNode gNode = gotNode.nodes[i]; - if (!CompareRecursive(eNode, gNode)) - return false; - } - return true; - } - - #endregion Config Node Utilities - - #region logging - - public void addErrorFiles(UrlDir.UrlFile file, int n = 1) - { - string key = file.url + "." + file.fileExtension; - if (key[0] == '/') - key = key.Substring(1); - if (!errorFiles.ContainsKey(key)) - errorFiles.Add(key, n); - else - errorFiles[key] = errorFiles[key] + n; - } - - public static void log(String s) - { - print("[ModuleManager] " + s); - } - - #endregion logging - - #region Tests - - private void RunTestCases() - { - log("Running tests..."); - - // Do MM testcases - foreach (UrlDir.UrlConfig expect in GameDatabase.Instance.GetConfigs("MMTEST_EXPECT")) - { - // So for each of the expects, we expect all the configs before that node to match exactly. - UrlDir.UrlFile parent = expect.parent; - if (parent.configs.Count != expect.config.CountNodes + 1) - { - log("Test " + parent.name + " failed as expected number of nodes differs expected:" + - expect.config.CountNodes + " found: " + parent.configs.Count); - for (int i = 0; i < parent.configs.Count; ++i) - log(parent.configs[i].config.ToString()); - continue; - } - for (int i = 0; i < expect.config.CountNodes; ++i) - { - ConfigNode gotNode = parent.configs[i].config; - ConfigNode expectNode = expect.config.nodes[i]; - if (!CompareRecursive(expectNode, gotNode)) - { - log("Test " + parent.name + "[" + i + - "] failed as expected output and actual output differ.\nexpected:\n" + expectNode + - "\nActually got:\n" + gotNode); - } - } - - // Purge the tests - parent.configs.Clear(); - } - log("tests complete."); - } - - #endregion Tests - } -}