private static void SetLangVersion(XElement projectElement, XNamespace xmlns)
{
// Set the C# language level, so Rider doesn't have to guess (although it does a good job)
// VSTU sets this, and I think newer versions of Unity do too (should check which version)
SetOrUpdateProperty(projectElement, xmlns, "LangVersion", existing =>
{
if (PluginSettings.OverrideLangVersion)
{
return(PluginSettings.LangVersion);
}
var expected = GetExpectedLanguageLevel();
if (expected == "latest" || existing == "latest")
{
return("latest");
}
// Only use our version if it's not already set, or it's less than what we would set
// Note that if existing is "default", we'll override it
var currentIsParsed = VersionExtensions.TryParse(existing, out var currentLanguageLevel);
var expectedIsParsed = VersionExtensions.TryParse(expected, out var expectedLanguageLevel);
if (currentIsParsed && expectedIsParsed && currentLanguageLevel < expectedLanguageLevel ||
!currentIsParsed
)
{
return(expected);
}
return(existing);
});
}
public void GetComparableVersionsReturnOnlyValidVersion()
{
// Act
var versions = VersionExtensions.GetComparableVersionStrings(new SemanticVersion("1.3.2.4-beta")).ToArray();
// Assert
Assert.Equal(1, versions.Length);
Assert.Equal("1.3.2.4-beta", versions[0]);
}
public void Satisfies_Test(string version, string vToCheck, bool expectedResult)
{
var range = VersionExtensions.GetVersionRangeFromDependency(version);
var checkVersion = NuGet.Versioning.NuGetVersion.Parse(vToCheck);
var result = new VersionRangeExtended(range).Satisfies(checkVersion);
Assert.Equal(expectedResult, result);
}
public void IsBetter_Test(string rangeString, string currentString, string consideringString, bool expectedResult)
{
var range = VersionExtensions.GetVersionRangeFromDependency(rangeString);
var current = NuGet.Versioning.NuGetVersion.Parse(currentString);
var considering = NuGet.Versioning.NuGetVersion.Parse(consideringString);
var result = new VersionRangeExtended(range).IsBetter(current, considering);
Assert.Equal(expectedResult, result);
}
public void GetComparableVersionsReturnMatchingVersionFirst3()
{
// Act
var versions = VersionExtensions.GetComparableVersionStrings(new SemanticVersion("1.3.2.0-beta")).ToArray();
// Assert
Assert.Equal(2, versions.Length);
Assert.Equal("1.3.2.0-beta", versions[0]);
Assert.Equal("1.3.2-beta", versions[1]);
}
public void GetComparableVersionsReturnMatchingVersionFirst2()
{
// Act
var versions = VersionExtensions.GetComparableVersionStrings(new SemanticVersion("2.0.0.0")).ToArray();
// Assert
Assert.Equal(3, versions.Length);
Assert.Equal("2.0.0.0", versions[0]);
Assert.Equal("2.0", versions[1]);
Assert.Equal("2.0.0", versions[2]);
}
/// <summary>
/// Creates a new command to get device info.
/// </summary>
/// <returns>A command with a replay that contains the firmware version, the starting address
/// and the ending address</returns>
/// <remarks>
/// This command gets information about the programmable brick. <c>fwVersion</c> is the
/// bootloader firmware version. <c>startAddress</c> is the starting address where the
/// firmware should be written (i.e. this value is passed to <see cref="WriteFirmware"/>).
/// <c>endAddess</c> is the final address where the firmware can be written. <c>hubType</c>
/// indicates the type of programmable brick.
/// </remarks>
public static Command <(Version fwVersion, uint startAddress, uint endAddress, HubType hubType)> DeviceInfo()
{
var message = new byte[] { 0x55 };
return(new Command <(Version, uint, uint, HubType)>(message, RequestTypes.Reply, reply => {
var fwVersion = VersionExtensions.ReadVersionLittleEndian(reply.Slice(1, 4));
var startAddress = BinaryPrimitives.ReadUInt32LittleEndian(reply.Slice(5, 4));
var endAddress = BinaryPrimitives.ReadUInt32LittleEndian(reply.Slice(9, 4));
var hubType = (HubType)reply[13];
return (fwVersion, startAddress, endAddress, hubType);
}));
}
public void CompareVersionTest()
{
Assert.IsTrue(VersionExtensions.CompareVersion(@"2.3.1.0", @"2.3.1") > 0); // wtf??? Be aware that
Assert.IsTrue(VersionExtensions.CompareVersion(@"2.0.0.0", @"2.3.1") < 0);
Assert.IsTrue(VersionExtensions.CompareVersion(@"1.3.1.0", @"2.3.1") < 0);
Assert.IsTrue(VersionExtensions.CompareVersion(@"2.3.1.0", @"1.3.1") > 0);
Assert.IsTrue(VersionExtensions.CompareVersion(@"1.2", @"1.3") < 0);
Assert.IsTrue(VersionExtensions.CompareVersion(@"1.3", @"1.2") > 0);
Assert.IsTrue(VersionExtensions.CompareVersion(@"1.3", @"1.3") == 0);
Assert.IsTrue(VersionExtensions.CompareVersion(@"1.2.1", @"1.2") > 0);
Assert.IsTrue(VersionExtensions.CompareVersion(@"2.3.1", @"2.4") < 0);
Assert.IsTrue(VersionExtensions.CompareVersion(@"1.3.2", @"1.3.1") > 0);
}
internal static Version GetIdAsVersionHelper(this Commit?commit, VersionOptions?versionOptions, int versionHeight)
{
var baseVersion = versionOptions?.Version?.Version ?? Version0;
int buildNumber = baseVersion.Build;
int revision = baseVersion.Revision;
// Don't use the ?? coalescing operator here because the position property getters themselves can return null, which should NOT be overridden with our default.
// The default value is only appropriate if versionOptions itself is null.
var versionHeightPosition = versionOptions is not null ? versionOptions.VersionHeightPosition : SemanticVersion.Position.Build;
var commitIdPosition = versionOptions is not null ? versionOptions.GitCommitIdPosition : SemanticVersion.Position.Revision;
// The compiler (due to WinPE header requirements) only allows 16-bit version components,
// and forbids 0xffff as a value.
if (versionHeightPosition.HasValue)
{
int adjustedVersionHeight = versionHeight == 0 ? 0 : versionHeight + (versionOptions?.VersionHeightOffset ?? 0);
Verify.Operation(adjustedVersionHeight <= MaximumBuildNumberOrRevisionComponent, "Git height is {0}, which is greater than the maximum allowed {0}.", adjustedVersionHeight, MaximumBuildNumberOrRevisionComponent);
switch (versionHeightPosition.Value)
{
case SemanticVersion.Position.Build:
buildNumber = adjustedVersionHeight;
break;
case SemanticVersion.Position.Revision:
revision = adjustedVersionHeight;
break;
}
}
if (commitIdPosition.HasValue)
{
switch (commitIdPosition.Value)
{
case SemanticVersion.Position.Revision:
revision = commit is object
?Math.Min(MaximumBuildNumberOrRevisionComponent, commit.GetTruncatedCommitIdAsUInt16())
: 0;
break;
}
}
return(VersionExtensions.Create(baseVersion.Major, baseVersion.Minor, buildNumber, revision));
}
public void GetVersionRangeFromDependency(string version, string expectedMinVersion, string expectedMaxVersion)
{
var expectedMin = expectedMinVersion == null ? null : new NuGet.Versioning.NuGetVersion(expectedMinVersion);
var expectedMax = expectedMaxVersion == null ? null : new NuGet.Versioning.NuGetVersion(expectedMaxVersion);
NuGet.Versioning.VersionRange range;
try
{
range = VersionExtensions.GetVersionRangeFromDependency(version);
}
catch
{
Assert.Null(expectedMin);
Assert.Null(expectedMax);
return;
}
Assert.Equal(expectedMin, range.MinVersion);
Assert.Equal(expectedMax, range.MaxVersion);
}
[InlineData("1.1.1-beta1", "1.1.1", null)] // Not supported
public void Satisfies_WithExtraLabel_Test(string version, string vToCheck, bool?expectedResult)
{
var range = VersionExtensions.GetVersionRangeFromDependency(version);
var checkVersion = NuGet.Versioning.NuGetVersion.Parse(vToCheck);
bool?result = null;
try
{
result = new VersionRangeExtended(range)
{
ReleaseLabel = "ABC"
}.Satisfies(checkVersion);
}
catch
{
Assert.Null(expectedResult);
}
Assert.Equal(expectedResult, result);
}
public int Compare(object?x, object?y)
{
return(VersionExtensions.CompareVersion(x?.ToString(), y?.ToString()));
}
// Set appropriate version
private static bool FixTargetFrameworkVersion(XElement projectElement, XNamespace xmlns)
{
return(SetOrUpdateProperty(projectElement, xmlns, "TargetFrameworkVersion", s =>
{
if (UnityUtils.ScriptingRuntime > 0)
{
if (PluginSettings.OverrideTargetFrameworkVersion)
{
return "v" + PluginSettings.TargetFrameworkVersion;
}
}
else
{
if (PluginSettings.OverrideTargetFrameworkVersionOldMono)
{
return "v" + PluginSettings.TargetFrameworkVersionOldMono;
}
}
if (string.IsNullOrEmpty(s))
{
ourLogger.Verbose("TargetFrameworkVersion in csproj is null or empty.");
return string.Empty;
}
var version = string.Empty;
try
{
version = s.Substring(1);
// for windows try to use installed dotnet framework
// Unity 2018.1 doesn't require installed dotnet framework, it references everything from Unity installation
if (PluginSettings.SystemInfoRiderPlugin.operatingSystemFamily == OperatingSystemFamilyRider.Windows && UnityUtils.UnityVersion < new Version(2018, 1))
{
var versions = PluginSettings.GetInstalledNetFrameworks();
if (versions.Any())
{
var versionOrderedList = versions.OrderBy(v1 => new Version(v1));
var foundVersion = UnityUtils.ScriptingRuntime > 0
? versionOrderedList.Last()
: versionOrderedList.First();
// Unity may require dotnet 4.7.1, which may not be present
var fvIsParsed = VersionExtensions.TryParse(foundVersion, out var fv);
var vIsParsed = VersionExtensions.TryParse(version, out var v);
if (fvIsParsed && vIsParsed && (UnityUtils.ScriptingRuntime == 0 || UnityUtils.ScriptingRuntime > 0 && fv > v))
{
version = foundVersion;
}
else if (foundVersion == version)
{
ourLogger.Verbose("Found TargetFrameworkVersion {0} equals the one set-by-Unity itself {1}",
foundVersion, version);
}
else if (ourLogger.IsVersboseEnabled())
{
var message = $"Rider may require \".NET Framework {version} Developer Pack\", which is not installed.";
Debug.Log(message);
}
}
}
}
catch (Exception e)
{
ourLogger.Log(LoggingLevel.WARN, "Fail to FixTargetFrameworkVersion", e);
}
return "v" + version;
}
));
}
/// <summary>
/// Default Constructor
/// </summary>
public SystemModelNamespaceSchema()
: base(Assembly.GetExecutingAssembly())
{
Version = VersionExtensions.Parse(CurrentVersion);
OldestCompatibleVersion = VersionExtensions.Parse("1.0.0d0");
}
public void ToDelegateRequiresNonNullVersionSpec()
{
ExceptionAssert.ThrowsArgNull(() => VersionExtensions.ToDelegate(null), "versionInfo");
}
public void ToDelegateWithExtractorRequiresNonNullParameters()
{
ExceptionAssert.ThrowsArgNull(() => VersionExtensions.ToDelegate <IPackage>(null, p => p.Version), "versionInfo");
ExceptionAssert.ThrowsArgNull(() => VersionExtensions.ToDelegate <IPackage>(new VersionSpec(new SemanticVersion(1, 0, 0, 0)), null), "extractor");
}
public NamespaceSchema()
: base(Assembly.GetExecutingAssembly())
{
Version = VersionExtensions.Parse(CurrentVersion);
OldestCompatibleVersion = VersionExtensions.Parse("0.1.0f0");
}
private static void RegisterMappings()
{
// Packages
TypeAdapterConfig <PackageSpec, XmlPackageSpec> .NewConfig()
.Map(dst => dst.Platform, src => src.Framework.GetShortFolderName());
TypeAdapterConfig <XmlPackageSpec, PackageSpec> .NewConfig()
.Map(dst => dst.Framework, src => PackageExtensions.GetFramework(src.Platform));
TypeAdapterConfig <PackageManifestRoot, XmlPackageManifestRoot> .NewConfig()
.Map(dst => dst.Platform, src => src.Framework.GetShortFolderName());
TypeAdapterConfig <XmlPackageManifestRoot, PackageManifestRoot> .NewConfig()
.Map(dst => dst.Framework, src => PackageExtensions.GetFramework(src.Platform));
TypeAdapterConfig <PackageManifest, XmlPackageManifest> .NewConfig()
.Include <PackageSpec, XmlPackageSpec>()
.Include <PackageManifestRoot, XmlPackageManifestRoot>()
.Map(dst => dst.Version, src => src.Version.ToString())
.Map(dst => dst.Platform, src => src.LegacyFramework);
TypeAdapterConfig <XmlPackageManifest, PackageManifest> .NewConfig()
.Include <XmlPackageSpec, PackageSpec>()
.Include <XmlPackageManifestRoot, PackageManifestRoot>()
.Map(dst => dst.Version, src => NuGet.Versioning.NuGetVersion.Parse(src.Version))
.Map(dst => dst.LegacyFramework, src => src.Platform);
TypeAdapterConfig <XmlPackageLegacyCrap, XmlPackageManifestRoot> .NewConfig();
TypeAdapterConfig <XmlPackageLegacyCrap, XmlPackageSpec> .NewConfig();
TypeAdapterConfig <PackageDependency, XmlPackageDependency> .NewConfig()
.Map(dst => dst.VersionPattern, src => src.AllowedVersions.OriginalString)
.Map(dst => dst.Platform, src => src.Framework);
TypeAdapterConfig <XmlPackageDependency, PackageDependency> .NewConfig()
.ConstructUsing(xml => new PackageDependency(xml.PackageId, VersionExtensions.GetVersionRangeFromDependency(xml.VersionPattern)))
.Ignore(dst => dst.PackageId, src => src.AllowedVersions)
.Map(dst => dst.Framework, src => src.Platform)
.AfterMapping((src, dst) =>
{
if (src.DevTimeOnly)
{
if (src.Scope == XmlDependencyScope.Normal)
{
dst.Scope = DependencyScope.Build;
}
}
else
{
if (src.Scope != XmlDependencyScope.Normal)
{
dst.Scope = DependencyScope.Normal;
}
}
});
TypeAdapterConfig <SourceFiles, XmlSourceFiles> .NewConfig();
TypeAdapterConfig <XmlSourceFiles, SourceFiles> .NewConfig();
TypeAdapterConfig <XmlRegisteredRepositories, RegisteredRepositories> .NewConfig();
TypeAdapterConfig <XmlRegisteredRepository, RegisteredRepository> .NewConfig();
TypeAdapterConfig <XmlRepositoryType, RepositoryType> .NewConfig();
// PackagesManager
TypeAdapterConfig <XmlInstalledPackagesIndex, InstalledPackagesIndex> .NewConfig()
.ConstructUsing(src => new InstalledPackagesIndex(MapContext.Current.Parameters["location"].ToString()));
TypeAdapterConfig <InstalledPackagesIndex, XmlInstalledPackagesIndex> .NewConfig();
TypeAdapterConfig <XmlPackageKey, PackageKey> .NewConfig()
.ConstructUsing(src => new PackageKey(src.PackageId, NuGet.Versioning.NuGetVersion.Parse(src.Version), src.Framework));
TypeAdapterConfig <PackageKey, XmlPackageKey> .NewConfig()
.Map(dst => dst.Version, src => src.Version.OriginalVersion);
}
