BadVersion.cs

Go to the documentation of this file.

using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop.Functions;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Interop.Common.Versioning;
 
public class BadVersion : BadObject, IBadNative
{
    public static readonly BadClassPrototype
        Prototype = new BadNativeClassPrototype<BadVersion>("Version", VersionCtor);
 
    private static readonly BadClassPrototype s_Prototype;
 
    private readonly BadObjectReference m_ChangeVersion;
 
    private readonly Version m_Version;
 
    static BadVersion()
    {
        s_Prototype = new BadNativeClassPrototype<BadVersion>("Version", VersionCtor);
    }
 
    public BadVersion(Version version)
    {
        m_Version = version;
        m_ChangeVersion = BadObjectReference.Make(
            "Version.ChangeVersion",
            () => new BadDynamicInteropFunction<string>(
                "ChangeVersion",
                (_, s) => new BadVersion(m_Version.ChangeVersion(s)),
                s_Prototype
            )
        );
    }
 
    public bool Equals(IBadNative other)
    {
        return other is BadVersion v && m_Version.Equals(v.m_Version);
    }
 
    public object Value => m_Version;
 
    public Type Type => typeof(Version);
 
 
    public override bool HasProperty(string propName, BadScope? caller = null)
    {
        return propName is "Major" or "Minor" or "Build" or "Revision" ||
               base.HasProperty(propName, caller);
    }
 
    public override BadObjectReference GetProperty(string propName, BadScope? caller = null)
    {
        return propName switch
        {
            "Major" => BadObjectReference.Make("Version.Major", () => m_Version.Major),
            "Minor" => BadObjectReference.Make("Version.Minor", () => m_Version.Minor),
            "Build" => BadObjectReference.Make("Version.Build", () => m_Version.Build),
            "Revision" => BadObjectReference.Make("Version.Revision", () => m_Version.Revision),
            "ChangeVersion" => m_ChangeVersion,
            _ => base.GetProperty(propName, caller),
        };
    }
 
    public override BadClassPrototype GetPrototype()
    {
        return s_Prototype;
    }
 
    private static BadObject VersionCtor(BadExecutionContext ctx, BadObject[] args)
    {
        switch (args.Length)
        {
            case 0:
                return new BadVersion(new Version());
            case 1:
                return args[0] is IBadString str
                    ? new BadVersion(new Version(str.Value))
                    : throw BadRuntimeException.Create(ctx.Scope, "Version Constructor expects string as argument");
            case >= 2:
            {
                if (args[0] is not IBadNumber major)
                {
                    throw BadRuntimeException.Create(ctx.Scope, "Expected major version to be a number");
                }
 
                if (args[1] is not IBadNumber minor)
                {
                    throw BadRuntimeException.Create(ctx.Scope, "Expected minor version to be a number");
                }
 
                if (args.Length == 2)
                {
                    return new BadVersion(new Version((int)major.Value, (int)minor.Value));
                }
 
                if (args[2] is not IBadNumber build)
                {
                    throw BadRuntimeException.Create(ctx.Scope, "Expected build version to be a number");
                }
 
                if (args.Length == 3)
                {
                    return new BadVersion(new Version((int)major.Value, (int)minor.Value, (int)build.Value));
                }
 
                if (args[3] is not IBadNumber revision)
                {
                    throw BadRuntimeException.Create(ctx.Scope, "Expected revision version to be a number");
                }
 
                if (args.Length == 4)
                {
                    return new BadVersion(
                        new Version(
                            (int)major.Value,
                            (int)minor.Value,
                            (int)build.Value,
                            (int)revision.Value
                        )
                    );
                }
 
                break;
            }
        }
 
        throw BadRuntimeException.Create(ctx.Scope, "Invalid Argument Count for Version Constructor");
    }
 
    public override string ToSafeString(List<BadObject> done)
    {
        return m_Version.ToString();
    }
}