private void AddPackageItemToDictionary(Dictionary <string, PackageItem> packageItems, PackageItem packageItem)
{
if (packageItems.ContainsKey(packageItem.Name))
{
if (comparer == null)
{
comparer = new VersionComparer(VersionComparison.VersionRelease);
}
if (comparer.Compare(packageItems[packageItem.Name].Version, packageItem.Version) != 0 && UseNewestAvailablePackages != true)
{
Log.LogError("Package named {0} already exists. Cannot have multiple packages with the same name.\n", packageItem.Name);
Log.LogError("To permit package name clashes and take latest, specify 'UseNewestAvailablePackages=true'.\n");
Log.LogError("Package {0} version {1} clashes with {2}", packageItem.Name, packageItems[packageItem.Name].Version.ToFullString(), packageItem.Version.ToFullString());
}
else if (UseNewestAvailablePackages == true)
{
PackageItem item = (comparer.Compare(packageItems[packageItem.Name].Version, packageItem.Version) < 0) ? packageItem : packageItems[packageItem.Name];
packageItems[packageItem.Name] = item;
}
}
else
{
packageItems.Add(packageItem.Name, packageItem);
}
}
public ActionResult ViewIgChanges(int id)
{
if (!CheckPoint.Instance.GrantViewImplementationGuide(id))
{
throw new AuthorizationException("You do not have access to view this implementation guide's changes.");
}
ImplementationGuide lGuide = this.tdb.ImplementationGuides.Single(ig => ig.Id == id);
ViewChangesModel lModel = new ViewChangesModel();
IGSettingsManager igSettings = new IGSettingsManager(this.tdb, lGuide.Id);
IIGTypePlugin igTypePlugin = lGuide.ImplementationGuideType.GetPlugin();
VersionComparer lComparer = VersionComparer.CreateComparer(tdb, igTypePlugin, igSettings);
lModel.IgName = lGuide.Name;
// Modified templates
foreach (Template lNewTemplate in lGuide.ChildTemplates.Where(t => t.PreviousVersionTemplateId.HasValue))
{
Template lPreviousVersion = this.tdb.Templates.Single(t => t.Id == lNewTemplate.PreviousVersionTemplateId.Value);
ComparisonResult lResult = lComparer.Compare(lPreviousVersion, lNewTemplate);
lModel.TemplateDifferences.Add(
new DifferenceModel(lResult)
{
Id = lNewTemplate.Id,
IsAdded = false,
TemplateName = lNewTemplate.Name,
PreviousTemplateName = string.Format("{0} ({1})", lPreviousVersion.Name, lPreviousVersion.Oid),
PreviousTemplateId = lPreviousVersion.Id,
Difference = lResult,
InlineConstraints = GetInlineConstraintChanges(lResult)
});
}
// Added templates
foreach (Template lNewTemplate in lGuide.ChildTemplates.Where(t => !t.PreviousVersionTemplateId.HasValue))
{
ComparisonResult lResult = lComparer.Compare(new Template(), lNewTemplate);
lModel.TemplateDifferences.Add(
new DifferenceModel(lResult)
{
Id = lNewTemplate.Id,
IsAdded = true,
TemplateName = lNewTemplate.Name
});
}
return(View(lModel));
}
/// <summary>
/// If this IG is a new version of a previous IG, scan the templates for new versions and add them as an appendix
/// </summary>
private void LoadChangesAppendix()
{
List <IGDifferenceViewModel> lDifferences = new List <IGDifferenceViewModel>();
if (this.implementationGuide.PreviousVersionImplementationGuideId.HasValue)
{
VersionComparer lComparer = VersionComparer.CreateComparer(_tdb);
var versionedTemplates = this._templates.Where(y => y.OwningImplementationGuideId == this.implementationGuide.Id);
foreach (Template lChildTemplate in versionedTemplates)
{
IGDifferenceViewModel lModel
= new IGDifferenceViewModel()
{
TemplateName = lChildTemplate.Name,
TemplateOid = lChildTemplate.Oid,
TemplateBookmark = lChildTemplate.Bookmark
};
if (lChildTemplate.PreviousVersionTemplateId.HasValue)
{
Template lPreviousTemplate = _tdb.Templates.Single(t => t.Id == lChildTemplate.PreviousVersionTemplateId);
lModel.Difference = lComparer.Compare(lPreviousTemplate, lChildTemplate);
lDifferences.Add(lModel);
}
}
this.LoadDifferencesAsAppendix(this.implementationGuide.Name, lDifferences);
}
}
public void CompareRightNull()
{
SemanticVersion left = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(1, comparer.Compare(left, null));
}
public void CompareLeftNull()
{
SemanticVersion right = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(-1, comparer.Compare(null, right));
}
public void CompareRightNull()
{
SemanticVersion left = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(1, comparer.Compare(left, null));
}
public void CompareLeftNull()
{
SemanticVersion right = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(-1, comparer.Compare(null, right));
}
public void VersionRelease_Compare_Test(string v1, string v2, int expectedResult)
{
var version1 = NuGet.Versioning.NuGetVersion.Parse(v1);
var version2 = NuGet.Versioning.NuGetVersion.Parse(v2);
var result = VersionComparer.Compare(version1, version2, VersionComparison.VersionRelease);
Assert.Equal(expectedResult, result);
}
public void Compare()
{
SemanticVersion left = new SemanticVersion(1, 0, 0);
SemanticVersion right = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(0,comparer.Compare(left, right));
}
public void Compare()
{
SemanticVersion left = new SemanticVersion(1, 0, 0);
SemanticVersion right = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(0, comparer.Compare(left, right));
}
private void compareToolStripMenuItem_Click(object sender, EventArgs e)
{
if (compareToolStripMenuItem.Text == __Compare)
{
if (lvwVersions.SelectedItems.Count == 2)
{
VersionComparer.Compare(VersionObjectType, ObjectName, (IdpeVersion)lvwVersions.SelectedItems[0].Tag, (IdpeVersion)lvwVersions.SelectedItems[1].Tag);
}
}
else if (compareToolStripMenuItem.Text == __SetToTheVersion)
{
if (lvwVersions.SelectedItems.Count == 1)
{
IdpeVersion version = lvwVersions.SelectedItems[0].Tag as IdpeVersion;
if (MessageBox.Show(string.Format("Are you sure you want to revert '{0}' to Version {1}?", ObjectName, version.Version)
, "Revert Version", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == System.Windows.Forms.DialogResult.Yes)
{
try
{
this.Cursor = Cursors.WaitCursor;
switch (VersionObjectType)
{
case VersionObjectTypes.Attribute:
break;
case VersionObjectTypes.DataSource:
DataSourceBundle dataSourceBundle = VersionComparer.ConvertToSreVersionObject(VersionObjectTypes.DataSource, version) as DataSourceBundle;
dataSourceBundle.Import();
Reverted = true;
break;
case VersionObjectTypes.Rule:
DataSourcePatch dataSourcePatch = VersionComparer.ConvertToSreVersionObject(VersionObjectTypes.Rule, version) as DataSourcePatch;
dataSourcePatch.Import();
Reverted = true;
break;
}
//this.Close();
}
catch (Exception ex)
{
//toolStripStatusLabel1.Text = ex.Message;
}
finally
{
this.Cursor = Cursors.Default;
}
}
}
}
if (Reverted)
{
this.ParentForm.DialogResult = DialogResult.OK;
this.ParentForm.Close();
}
}
public void Comparisons()
{
var comparer = new VersionComparer();
int c1 = comparer.Compare("0.10.0", "0.2");
Assert.Equal(1, c1);
int c2 = comparer.Compare(default, "0.2");
public void ComparePrereleaseNonnumeric()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "42.alpha");
SemanticVersion right = new SemanticVersion(1, 0, 0, "42.beta");
VersionComparer comparer = new VersionComparer();
// "identifiers with letters or hyphens are compared lexically in ASCII sort order"
Assert.Equal(-1, comparer.Compare(left, right));
}
public void ComparePrereleaseNumeric()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "alpha.23");
SemanticVersion right = new SemanticVersion(1, 0, 0, "alpha.5");
VersionComparer comparer = new VersionComparer();
// "identifiers consisting of only digits are compared numerically"
Assert.Equal(1, comparer.Compare(left, right));
}
static async Task <UpdateResult> DoUpdate(bool useMaster = false)
{
try
{
string tree;
var repo = XianxiaRepo;
if (useMaster)
{
tree = "master-wip";
}
else
{
tree = await GitHubGetters.GetLatestVersion(repo);
}
var xmlPath = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName);
xmlPath = Path.Combine(xmlPath, XmlData.Files.Xianxia);
XmlDataSet fileData = XmlData._LoadXmlData(xmlPath);
if (useMaster == false)
{
var currentVersion = NuGetVersion.Parse(fileData.Version);
var availableVersion = NuGetVersion.Parse(tree);
//If current version is at or greater than the available version, return
if (VersionComparer.Compare(currentVersion, availableVersion, VersionComparison.Default) >= 0)
{
Console.WriteLine("Xianxia data file is current, no need for update");
return(UpdateResult.NoneNecessary);
}
}
if (await UpdateStatusEffects(repo, tree, fileData) != UpdateResult.UpdatedFiles)
{
Console.WriteLine("Error! Could not parse status file!");
return(UpdateResult.Error);
}
if (await UpdateFlags(repo, tree, fileData) != UpdateResult.UpdatedFiles)
{
Console.WriteLine("Error! Could not parse flag file!");
return(UpdateResult.Error);
}
fileData.Version = tree;
if (XmlData._SaveXml(xmlPath, fileData) != XmlLoadingResult.Success)
{
Console.WriteLine("Error! Could not save xml!");
return(UpdateResult.Error);
}
Console.WriteLine("saved xml!");
}
catch (Exception e)
{
Console.WriteLine("Error! " + e.ToString());
return(UpdateResult.Error);
}
return(UpdateResult.UpdatedFiles);
}
public void ComparePrereleaseNumericVsOther()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "alpha.1");
SemanticVersion right = new SemanticVersion(1, 0, 0, "alpha.beta");
VersionComparer comparer = new VersionComparer();
// "Numeric identifiers always have lower precedence than non-numeric identifiers."
// Meaning: "... precede ..." (as per the above example from the spec).
Assert.Equal(-1, comparer.Compare(left, right));
}
public void ComparePrereleaseRelease()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "beta");
SemanticVersion right = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
// "When major, minor, and patch are equal, a pre-release
// version has lower precedence than a normal version."
Assert.Equal(-1, comparer.Compare(left, right));
}
private static int CompareOneWay(VersionComparer comparer, string version1, string version2)
{
// Arrange
var a = Version.Parse(version1);
var b = Version.Parse(version2);
var c = Version.Parse(version1);
var d = Version.Parse(version2);
// Act
var results = new List <int>();
results.Add(comparer.Compare(a, b));
results.Add(comparer.Compare(a, d));
results.Add(comparer.Compare(c, b));
results.Add(comparer.Compare(c, d));
// Assert
Assert.True(results.FindAll(x => x == results[0]).Count == results.Count);
return(results[0]);
}
public void ComparePrereleaseFieldNumber()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "alpha");
SemanticVersion right = new SemanticVersion(1, 0, 0, "alpha.1");
VersionComparer comparer = new VersionComparer();
// "A larger set of pre-release fields has a higher
// precedence than a smaller set, if all of the preceding
// identifiers are equal."
Assert.Equal(-1, comparer.Compare(left, right));
}
public async Task <ActionResult <Models.ReleaseModel> > CheckAppVersionUpdateAsync([Required] string product, [Required] string platform, [Required] string arch, [Required] string version)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var latest = await _updater.FindLatestVersionAsync(product, platform, arch);
if (latest != null && _vComparer.Compare(version, latest.Version) < 0)
{
// convert to a Squirrel response
var squirrel = latest.ToSquirrelWindows();
return(Content(squirrel, "text/plain"));
}
return(NoContent());
}
/// <summary>
/// -1 if the client needs to upgrade (supported caps are lower)
/// 0 if the client and feed can work together.
/// 1 if the feed requires an upgrade due to being incompatible with the newer client
/// </summary>
private static int CompareCapabilities(List <FeedCapability> supportedCaps, List <FeedCapability> requiredCaps)
{
foreach (var cap in requiredCaps)
{
var supportedCap = supportedCaps.FirstOrDefault(e => StringComparer.OrdinalIgnoreCase.Equals(e.Name, cap.Name));
if (supportedCap == null)
{
// The feed is newer
return(-1);
}
// Versions must be an exact match
var result = VersionComparer.Compare(supportedCap.Version, cap.Version, VersionComparison.Version);
if (result != 0)
{
return(result);
}
}
return(0);
}
private int CompareVersion(NuGetVersion v1, NuGetVersion v2) => VersionComparer.Compare(v1, v2, VersionComparison.Version);
public void VersionComparerTest1()
{
Template parentTemplate = this.mockRepo.GenerateTemplate("3.2.1.4.3", this.documentType, "Parent Template", this.ig);
Template aTemplate = this.mockRepo.GenerateTemplate("1.2.3.4", this.documentType, "Test Template", this.ig, description: "Test Description 1");
aTemplate.IsOpen = false;
this.mockRepo.GenerateConstraint(aTemplate, null, null, "id", "SHALL", "1..1", number: 1);
this.mockRepo.GenerateConstraint(aTemplate, null, null, "effectiveTime", "SHALL", "1..1", number: 2);
this.mockRepo.GenerateConstraint(aTemplate, null, null, "entryRelationship", "SHALL", "1..1", number: 3);
Template bTemplate = this.mockRepo.GenerateTemplate("4.3.2.1", this.documentType, "New Test Template", this.ig, description: "Test Description 2", impliedTemplate: parentTemplate);
bTemplate.IsOpen = true;
this.mockRepo.GenerateConstraint(bTemplate, null, null, "id", "SHALL", "1..*", number: 1);
this.mockRepo.GenerateConstraint(bTemplate, null, null, "entryRelationship", "SHALL", "1..1", number: 3);
this.mockRepo.GenerateConstraint(bTemplate, null, null, "author", "SHALL", "1..1", number: 4);
VersionComparer comparer = VersionComparer.CreateComparer(mockRepo);
ComparisonResult compared = comparer.Compare(aTemplate, bTemplate);
// Test template changes
Assert.AreEqual(5, compared.ChangedFields.Count, "Expected to find 5 template fields changed");
var changedName = compared.ChangedFields.Single(y => y.Name == "Name");
Assert.AreEqual(aTemplate.Name, changedName.Old);
Assert.AreEqual(bTemplate.Name, changedName.New);
var changedDescription = compared.ChangedFields.Single(y => y.Name == "Description");
Assert.AreEqual(aTemplate.Description, changedDescription.Old);
Assert.AreEqual(bTemplate.Description, changedDescription.New);
var changedOid = compared.ChangedFields.Single(y => y.Name == "Oid");
Assert.AreEqual(aTemplate.Oid, changedOid.Old);
Assert.AreEqual(bTemplate.Oid, changedOid.New);
var changedImpliedTemplate = compared.ChangedFields.Single(y => y.Name == "Implied Template");
Assert.AreEqual("", changedImpliedTemplate.Old);
Assert.AreEqual("Parent Template (3.2.1.4.3)", changedImpliedTemplate.New);
var changedIsOpen = compared.ChangedFields.Single(y => y.Name == "Open/Closed");
Assert.AreEqual("Closed", changedIsOpen.Old);
Assert.AreEqual("Open", changedIsOpen.New);
// Test constraint changes
Assert.AreEqual(4, compared.ChangedConstraints.Count, "Expected to find 3 changed constraints");
var removedConstraint = compared.ChangedConstraints.Single(y => y.Type == CompareStatuses.Removed);
Assert.AreEqual("1-2", removedConstraint.Number);
Assert.AreEqual(0, removedConstraint.ChangedFields.Count);
Assert.IsFalse(string.IsNullOrEmpty(removedConstraint.OldNarrative));
var addedConstraint = compared.ChangedConstraints.Single(y => y.Type == CompareStatuses.Added);
Assert.AreEqual("1-4", addedConstraint.Number);
Assert.AreEqual(0, addedConstraint.ChangedFields.Count);
Assert.IsFalse(string.IsNullOrEmpty(addedConstraint.NewNarrative));
var changedConstraint = compared.ChangedConstraints.Single(y => y.Type == CompareStatuses.Modified);
Assert.AreEqual("1-1", changedConstraint.Number);
Assert.IsFalse(string.IsNullOrEmpty(changedConstraint.NewNarrative));
Assert.IsFalse(string.IsNullOrEmpty(changedConstraint.OldNarrative));
Assert.AreNotEqual(changedConstraint.OldNarrative, changedConstraint.NewNarrative);
Assert.AreEqual(1, changedConstraint.ChangedFields.Count);
Assert.IsNotNull(changedConstraint.ChangedFields.SingleOrDefault(y => y.Name == "Cardinality"));
var unchangedConstraint = compared.ChangedConstraints.Single(y => y.Type == CompareStatuses.Unchanged);
Assert.AreEqual("1-3", unchangedConstraint.Number);
}
public void Compare_min()
{
//arrange
string stEtalon = "15.2.9";
string stMajorMin = "14.2.9";
string stMajorMax = "16.2.9";
string stMinorMin = "15.1.9";
string stMinorMax = "16.1.9";
string stBuildMin = "15.2.8";
string stBuildMax = "15.2.10";
VersionComparer comp = new VersionComparer();
//act
int majMinRes = comp.Compare(stEtalon, stMajorMin);
int majMaxRes = comp.Compare(stEtalon, stMajorMax);
int minMinRes = comp.Compare(stEtalon, stMinorMin);
int mimMaxRes = comp.Compare(stEtalon, stMinorMax);
int buildMinRes = comp.Compare(stEtalon, stBuildMin);
int buildMaxRes = comp.Compare(stBuildMin, stBuildMax);
//assert
Assert.AreEqual(-1, majMinRes);
Assert.AreEqual(1, majMaxRes);
Assert.AreEqual(-1, minMinRes);
Assert.AreEqual(1, mimMaxRes);
Assert.AreEqual(-1, buildMinRes);
Assert.AreEqual(1, buildMaxRes);
}
public void CompareBothNull()
{
VersionComparer comparer = new VersionComparer();
Assert.Equal(0, comparer.Compare(null, null));
}
public void CompareBothNull()
{
VersionComparer comparer = new VersionComparer();
Assert.Equal(0, comparer.Compare(null, null));
}
public int Compare(Version version, Version otherVersion) => VersionComparer.Compare(version, otherVersion);
