EngineVersion.cs

Go to the documentation of this file.

using System;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Linq;
 
using Tgstation.Server.Common.Extensions;
 
namespace Tgstation.Server.Api.Models
{
    public sealed class EngineVersion : IEquatable<EngineVersion>
    {
        static readonly char[] DashChar = ['-'];
 
        [RequestOptions(FieldPresence.Required)]
        public EngineType? Engine { get; set; }
 
        [ResponseOptions]
        public Version? Version { get; set; }
 
        [ResponseOptions]
        [StringLength(Limits.MaximumCommitShaLength, MinimumLength = Limits.MaximumCommitShaLength)]
        public string? SourceSHA { get; set; }
 
        [ResponseOptions]
        public int? CustomIteration { get; set; }
 
        public static bool TryParse(string input, out EngineVersion? engineVersion)
        {
            if (input == null)
                throw new ArgumentNullException(nameof(input));
 
            var splits = input.Split(DashChar, StringSplitOptions.RemoveEmptyEntries);
            engineVersion = null;
 
            if (splits.Length > 3)
                return false;
 
            EngineType engine;
            var hasPrefix = splits.Length > 1;
            if (hasPrefix)
            {
                if (!Enum.TryParse(splits[0], out engine))
                    return false;
            }
            else
                engine = EngineType.Byond;
 
            Version? version;
            string? sha;
            int? customRev = null;
            if (engine == EngineType.Byond)
            {
                if (!Version.TryParse(splits.Last(), out version))
                    return false;
 
                if (version.Build > 0)
                {
                    customRev = version.Build;
                    version = new Version(version.Major, version.Minor);
                }
 
                sha = null;
            }
            else
            {
                Debug.Assert(engine == EngineType.OpenDream, "This does not support whatever ungodly new engine you've added");
 
                var shaIndex = hasPrefix ? 1 : 0;
                sha = splits[shaIndex];
                if (sha.Length != Limits.MaximumCommitShaLength)
                    return false;
 
                version = null;
 
                if (splits.Length - 1 > shaIndex)
                {
                    if (!Int32.TryParse(splits.Last(), out var customRevResult))
                        return false;
 
                    customRev = customRevResult;
                }
            }
 
            engineVersion = new EngineVersion
            {
                Engine = engine,
                Version = version,
                SourceSHA = sha,
                CustomIteration = customRev,
            };
            return true;
        }
 
        public static EngineVersion Parse(string input)
        {
            if (input == null)
                throw new ArgumentNullException(nameof(input));
 
            if (TryParse(input, out var engineVersion))
                return engineVersion!;
 
            throw new InvalidOperationException($"Invalid engine version: {input}");
        }
 
        public EngineVersion()
        {
        }
 
        public EngineVersion(EngineVersion other)
        {
            if (other == null)
                throw new ArgumentNullException(nameof(other));
 
            Version = other.Version;
            Engine = other.Engine;
            SourceSHA = other.SourceSHA;
            CustomIteration = other.CustomIteration;
        }
 
        public bool Equals(EngineVersion other)
        {
            // https://github.com/dotnet/roslyn-analyzers/issues/2875
#pragma warning disable CA1062 // Validate arguments of public methods
            return other!.Version?.Semver() == Version?.Semver()
                && other.Engine == Engine
                && (other.SourceSHA == SourceSHA
                || (other.SourceSHA != null
                    && SourceSHA != null
                    && other.SourceSHA.Equals(SourceSHA, StringComparison.OrdinalIgnoreCase)))
                && other.CustomIteration == CustomIteration;
#pragma warning restore CA1062 // Validate arguments of public methods
        }
 
        public override bool Equals(object obj)
            => obj is EngineVersion other && Equals(other);
 
        public override string ToString()
        {
            var isByond = Engine == EngineType.Byond;
 
            // BYOND encodes differently for backwards compatibility
            var enginePrefix = !isByond
                ? $"{Engine}-"
                : String.Empty;
            var displayedVersion = isByond
                ? (CustomIteration.HasValue
                    ? new Version(Version!.Major, Version.Minor, CustomIteration.Value)
                    : Version!).ToString()
                : SourceSHA;
            var displayedCustomIteration = !isByond && CustomIteration.HasValue
                ? $"-{CustomIteration}"
                : String.Empty;
            return $"{enginePrefix}{displayedVersion}{displayedCustomIteration}";
        }
 
        public override int GetHashCode() => ToString().GetHashCode();
    }
}