private void AddUnityPackages(List <Upset> upsetList)
{
string[] files = Directory.GetFiles(Path, "*.*");
Version Unity5 = new Version {
Major = 5
};
foreach (string FileName in files)
{
try
{
if (!IsUnityPackage(FileName))
{
continue;
}
// assume unityPackage doesn't contain an upset file for now. In the future we can support it
Upset upset = TryLoadUpset(FileName);
if (upset == null)
{
continue;
}
// Note: the spec may contain incomplete unity version here (e.g. 5.6). Maybe we should have a ParseThinUnityVersion
if (VersionParser.ParseIncompleteVersion(upset.UnityVersion) < Unity5)
{
throw new NotSupportedException("The package has been packed by a Unity version prior to Unity5, and we do not support this. Contact the package maintainer for updated version.");
}
upsetList.Add(upset);
}
catch (Exception e)
{
UnityEngine.Debug.LogErrorFormat("Could not load package at {0}, ignoring it ({1}):\n{2}", FileName, e.Message, e.StackTrace);
}
}
}
public async static Task CheckAppVersion()
{
try
{
var vp = new VersionParser();
if (!vp.Valid)
{
return;
}
if (!vp.IsNewer)
{
return;
}
if (!App.SplashScreen.AskUpdate($"TCC v{vp.NewVersionNumber} available. Download now?"))
{
return;
}
await Update(vp.NewVersionUrl);
}
catch (Exception e)
{
Log.F($"Error while checking update. \nException:\n{e.Message}\n{e.StackTrace}");
if (!App.SplashScreen.AskUpdate("Error while checking updates. Try again?"))
{
return;
}
await CheckAppVersion();
}
}
public void ParseCorrectUnityVersions()
{
Assert.AreEqual(VersionParser.ParseUnityVersion("1.2.3f4"),
new Version
{
Major = 1,
Minor = 2,
Patch = 3,
Optional = 4
}
);
Assert.AreEqual(VersionParser.ParseUnityVersion("5.6.1b1"),
new Version
{
Major = 5,
Minor = 6,
Patch = 1,
Optional = 1
}
);
Assert.AreEqual(VersionParser.ParseUnityVersion("2017.1.0a3"),
new Version
{
Major = 2017,
Minor = 1,
Patch = 0,
Optional = 3
}
);
}
private static IEnumerator CheckForUpdateRoutine()
{
IEnumerator e = GitHub.LoadReleases("https://api.github.com/repos/DragonBox/uplift/releases");
while (e.MoveNext())
{
yield return(e.Current);
}
GitHubRelease[] releases = (GitHubRelease[])e.Current;
if (releases == null)
{
Debug.LogError("Unable to check for Uplift updates");
}
else if (!releases.Any(release => VersionParser.GreaterThan(release.tag, About.Version)))
{
Debug.Log("No udpate for Uplift available");
}
else
{
UpdatePopup popup = EditorWindow.GetWindow(typeof(UpdatePopup), true) as UpdatePopup;
popup.SetReleases(releases.Where(release => VersionParser.GreaterThan(release.tag, About.Version, true)).ToArray());
}
EditorApplication.update -= EditorUpdate;
EditorPrefs.SetString(
lastUpdateCheckKey,
DateTime.UtcNow.ToString(dateFormat, provider)
);
}
/// <summary>
/// Build Engine Version.
/// </summary>
/// <param name="engine">The Engine.</param>
/// <returns>Return Match.</returns>
protected string BuildEngineVersion(string engine)
{
var engineVersion = new VersionParser(this.UserAgent, engine);
var result = engineVersion.Parse();
return(result.Success ? result.Match.Name : string.Empty);
}
// int has 32 bits
// Sign | Major | Minor | Build | Revision
// x | xxxxxxxxxx | xxxxxxx | xxxxxxx | xxxxxxx
// 1 bit | 10 bits | 7 bits | 7 bits | 7 bits
public int PackageVersionAsNumber()
{
VersionParser.VersionStruct version = VersionParser.ParseVersion(PackageVersion);
return((version.Major & 2047) << 21 +
(version.Minor & 255) << 14 +
(version.Build & 255) << 7 +
(version.Revision & 255));
}
/// <summary>
/// Initializes a new instance of the <see cref="Package"/> class.
/// </summary>
/// <param name="name">The package name.</param>
/// <param name="version">Normalized version.</param>
/// <param name="versionPretty">The package non-normalized version(Human readable).</param>
public Package(string name, string version, string versionPretty)
: base(name)
{
this.version = version;
this.versionPretty = versionPretty;
stability = VersionParser.ParseStability(version);
}
public static IPackage MockPackage(
string name, string version, Link[] provides = null,
Link[] replaces = null, Link[] requires = null, Link[] conflict = null,
string type = null)
{
// todo: optimization MockPackage, use GetPackage<T>().
provides = provides ?? Array.Empty <Link>();
replaces = replaces ?? Array.Empty <Link>();
requires = requires ?? Array.Empty <Link>();
conflict = conflict ?? Array.Empty <Link>();
var names = new[] { name.ToLower() };
var package = new Mock <IPackage>();
IRepository repository = null;
names = names.Concat(provides.Select((link) => link.GetTarget())).ToArray();
names = names.Concat(replaces.Select((link) => link.GetTarget())).ToArray();
package.Setup((o) => o.GetName()).Returns(() => name.ToLower());
package.Setup((o) => o.GetNamePretty()).Returns(() => name);
package.Setup((o) => o.GetPackageType()).Returns(() => type);
package.Setup((o) => o.GetVersion()).Returns(() => GetVersionParser().Normalize(version));
package.Setup((o) => o.GetVersionPretty()).Returns(() => version);
package.Setup((o) => o.GetNames()).Returns(() => names);
package.Setup((o) => o.GetStability()).Returns(() => VersionParser.ParseStability(version));
package.Setup((o) => o.GetProvides()).Returns(() => provides);
package.Setup((o) => o.GetReplaces()).Returns(() => replaces);
package.Setup((o) => o.GetConflicts()).Returns(conflict);
package.Setup((o) => o.GetRequires()).Returns(() => requires);
package.Setup((o) => o.ToString()).Returns(() => package.Object.GetNameUnique());
package.Setup((o) => o.GetPrettyString()).Returns(package.Object.GetNamePretty() + Str.Space + package.Object.GetVersionPretty());
package.Setup((o) => o.GetNameUnique()).Returns(() => package.Object.GetName() + "-" + package.Object.GetVersion());
package.Setup((o) => o.Equals(It.IsAny <IPackage>())).Returns((IPackage other) =>
{
IPackage self = package.Object;
if (self is PackageAlias packageAlias)
{
self = packageAlias.GetAliasOf();
}
if (other is PackageAlias objPackageAlias)
{
other = objPackageAlias.GetAliasOf();
}
return(other.GetNameUnique() == self.GetNameUnique());
});
package.Setup((o) => o.SetRepository(It.IsAny <IRepository>())).Callback((IRepository repo) =>
{
repository = repo;
});
package.Setup((o) => o.GetRepository()).Returns(() => repository);
package.SetupProperty((o) => o.Id);
return(package.Object);
}
public void ParseExactRequirement()
{
IVersionRequirement parsed = VersionParser.ParseRequirement("1.2.3!");
Assert.IsTrue(parsed is ExactVersionRequirement);
Assert.AreEqual((parsed as ExactVersionRequirement).expected, new Version {
Major = 1, Minor = 2, Patch = 3
});
}
public void ParsesVersionCorrectly(string input, string expectedPrerelease, string expectedBuild)
{
var version = VersionParser.Parse(input);
var output = version.ToString();
Assert.AreEqual(expectedPrerelease, version.Prerelease);
Assert.AreEqual(expectedBuild, version.Build);
}
public void ParseLoseRequirement()
{
IVersionRequirement parsed = VersionParser.ParseRequirement("1.2");
Assert.IsTrue(parsed is LoseVersionRequirement);
Assert.AreEqual((parsed as LoseVersionRequirement).stub, new Version {
Major = 1, Minor = 2
});
}
public void ParseBoundedRequirement()
{
IVersionRequirement parsed = VersionParser.ParseRequirement("1.2.*");
Assert.IsTrue(parsed is BoundedVersionRequirement);
Assert.AreEqual((parsed as BoundedVersionRequirement).lower, new Version {
Major = 1, Minor = 2
});
}
public void DoNotParseInvertedRangeRequirement()
{
Assert.Throws <System.ArgumentException>(
delegate
{
VersionParser.ParseRequirement("3.4,1.2");
}
);
}
public void ThrowsExceptionForMissingBranchName()
{
var context = new Context
{
Version = VersionParser.Parse("1.0")
};
ExceptionTester.CallMethodAndExpectException <ContinuaInitException>(() => context.ValidateContext());
}
public void ParseMinimalRequirement()
{
IVersionRequirement parsed = VersionParser.ParseRequirement("1.2+");
Assert.IsTrue(parsed is MinimalVersionRequirement);
Assert.AreEqual((parsed as MinimalVersionRequirement).minimal, new Version {
Major = 1, Minor = 2
});
}
public void TestLaxParse()
{
var parser = new VersionParser();
Assert.False(parser.TryParse("", out var _, false));
Assert.True(parser.TryParse("1", out var _, false));
Assert.True(parser.TryParse("1.0", out var _, false));
Assert.True(parser.TryParse("1.0.0", out var _, false));
Assert.False(parser.TryParse("1.0.0.0", out var _, false));
}
public void VersionParserResolvesOrderCorrectly()
{
SemVersion beta1 = VersionParser.FromSemanticString("0.5.0-beta.1");
SemVersion beta2 = VersionParser.FromSemanticString("0.5.0-beta.2");
SemVersion release = VersionParser.ZoombracoProductVersion();
Assert.True(release > beta1);
Assert.True(release > beta2);
Assert.True(beta2 > beta1);
}
//FIXME: Prepare proper version checker
public virtual void CheckUnityVersion()
{
string environmentVersion = Application.unityVersion;
if (VersionParser.ParseUnityVersion(environmentVersion) < VersionParser.ParseUnityVersion(UnityVersion))
{
Debug.LogError(string.Format("Upfile.xml Unity Version ({0}) targets a higher version of Unity than you are currently using ({1})",
UnityVersion, environmentVersion));
}
}
public void DoNotParseWrongRequirement()
{
// QUESTION: Should we not fail there?
Assert.Throws <System.ArgumentException>(
delegate
{
VersionParser.ParseRequirement("not.a.requirement");
}
);
}
public void ReturnsFalseForMasterBranch()
{
var context = new Context
{
BranchName = "master",
Version = VersionParser.Parse("1.0.0")
};
var rule = new DisplayVersionRule();
Assert.AreEqual("1.0.0", rule.GetParameter(context).Value);
}
public void ReturnsTrueForDevelopBranch()
{
var context = new Context
{
BranchName = "develop",
Version = VersionParser.Parse("1.0.0-unstable0001")
};
var rule = new DisplayVersionRule();
Assert.AreEqual("1.0.0-alpha0001", rule.GetParameter(context).Value);
}
public void SucceedsForValidContext()
{
var context = new Context
{
BranchName = "master",
Version = VersionParser.Parse("1.0")
};
// should not throw
context.ValidateContext();
}
public void TestParseNameVersionPairs(string expectedName, string expectedVersion, string[] input)
{
var versionParser = new VersionParser();
var result = versionParser.ParseNameVersionPairs(input);
Assert.AreEqual(1, result.Length);
var(actualName, actualVersion) = result[0];
Assert.AreEqual(expectedName, actualName);
Assert.AreEqual(expectedVersion, actualVersion);
}
public void ParseRangeRequirement()
{
IVersionRequirement parsed = VersionParser.ParseRequirement("1.2,3.4");
Assert.IsTrue(parsed is RangeVersionRequirement);
Assert.AreEqual((parsed as RangeVersionRequirement).lower, new Version {
Major = 1, Minor = 2
});
Assert.AreEqual((parsed as RangeVersionRequirement).upper, new Version {
Major = 3, Minor = 4
});
}
public DependencyNode(string name, string version, string repository, SkipInstallSpec[] skips, OverrideDestinationSpec[] overrides, List <DependencyNode> dependencies)
{
this.name = name;
this.requirement = VersionParser.ParseRequirement(version);
this.repository = repository;
this.dependencies = dependencies;
this.skips = skips;
this.overrides = overrides;
index = -1;
lowlink = -1;
}
public void ReturnsVersion(string input, string expectedOutput)
{
var context = new Context
{
BranchName = "master",
Version = VersionParser.Parse(input)
};
var rule = new MajorMinorPatchVersionRule();
var actualOutput = rule.GetParameter(context).Value;
Assert.AreEqual(expectedOutput, actualOutput);
}
public void ReturnsRightValue(string versionInput, bool expectedOutput)
{
var context = new Context
{
Version = VersionParser.Parse(versionInput)
};
var rule = new IsOfficialBuildRule();
var expected = expectedOutput.ToString().ToLower();
var actual = rule.GetParameter(context).Value.ToLower();
Assert.AreEqual(expected, actual);
}
public void ReturnsRightValue(string versionInput, string expectedOutput)
{
var context = new Context
{
Version = VersionParser.Parse(versionInput)
};
var rule = new PublishTypeRule();
var expected = expectedOutput.ToLower();
var actual = rule.GetParameter(context).Value.ToLower();
Assert.AreEqual(expected, actual);
}
private void ReadVersion()
{
TextAsset textFile = Resources.Load("version", typeof(TextAsset)) as TextAsset;
if (textFile == null)
{
return;
}
Debug.Log(textFile.text);
VersionParser parser = new VersionParser(textFile.text);
Bundle = parser.Bundle;
Resources.UnloadAsset(textFile);
}
/// <summary>
/// Initializes a new instance of the <see cref="PackageAlias"/> class.
/// </summary>
/// <param name="aliasOf">The package this package is an alias of.</param>
/// <param name="version">The version the alias must report.</param>
/// <param name="versionPretty">The alias's non-normalized version.</param>
public PackageAlias(IPackage aliasOf, string version, string versionPretty)
: base(aliasOf.GetName())
{
this.aliasOf = aliasOf;
this.version = version;
this.versionPretty = versionPretty;
stability = VersionParser.ParseStability(version);
requires = ReplaceSelfVersion(aliasOf.GetRequires(), nameof(requires), true);
requiresDev = ReplaceSelfVersion(aliasOf.GetRequiresDev(), nameof(requiresDev), true);
conflicts = ReplaceSelfVersion(aliasOf.GetConflicts(), nameof(conflicts));
provides = ReplaceSelfVersion(aliasOf.GetProvides(), nameof(provides));
replaces = ReplaceSelfVersion(aliasOf.GetReplaces(), nameof(replaces));
}
