public void SendDiff(string conferenceId, DiffItem diffItem) { DiffCommand command = new DiffCommand(conferenceId); command.DiffItem = diffItem; SendCommand(command); }
// olditem and newitem must be of same type, returning same list of items lists private static DiffItem CompareItems(ApiBaseItem oldItem, ApiBaseItem newItem) { DiffItem diff = new DiffItem(); diff.DiffType = oldItem == null ? DiffType.Added : newItem == null ? DiffType.Removed : DiffType.Changed; diff.Item = diff.DiffType == DiffType.Removed ? oldItem : newItem; ApiBaseItem item = oldItem ?? newItem; if (DetailedDetailLog || !(item is IApiType)) { ApiBaseItem[][] oldItemsItems = oldItem?.ApiItemsItems; ApiBaseItem[][] newItemsItems = newItem?.ApiItemsItems; ApiBaseItem[][] items = oldItemsItems ?? newItemsItems; for (int i = 0; i < items.Length; i++) { ApiBaseItem[] oldi = oldItemsItems != null ? oldItemsItems[i] : new ApiBaseItem[0]; ApiBaseItem[] newi = newItemsItems != null ? newItemsItems[i] : new ApiBaseItem[0]; diff.Children.AddRange(CompareItems(oldi, newi)); } } return(diff); }
public async Task <IActionResult> PutDiffItem(long id, DiffItem diffItem) { if (id != diffItem.id) { return(BadRequest()); } _context.Entry(diffItem).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!DiffItemExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <DiffItem> > PostDiffItem(DiffItem diffItem) { _context.DiffItems.Add(diffItem); await _context.SaveChangesAsync(); //return CreatedAtAction("GetDiffItem", new { id = diffItem.id }, diffItem); //CreatedAtAction method returns an HTTP 201 status code if successful (the standard response for an HTTP POST method that creates a new response on the server return(CreatedAtAction(nameof(GetDiffItem), new { id = diffItem.id }, diffItem)); }
private string objectNameFrom(DiffItem diffItem) { return (displayIf <IFormula>(diffItem, x => ancestorDisplayName(diffItem)) ?? displayIf <IReactionPartner>(diffItem, x => x.Partner.Name) ?? displayIf <IReactionPartnerBuilder>(diffItem, x => x.MoleculeName) ?? displayIf <UsedCalculationMethod>(diffItem, x => x.Category) ?? displayIf <IObjectPath>(diffItem, x => ancestorDisplayName(diffItem)) ?? displayIf <ValuePoint>(diffItem, x => ancestorDisplayName(diffItem)) ?? _displayNameProvider.DisplayNameFor(diffItem.Object1)); }
private static void CustomAction(string action, DiffItem item) { if (action == Actions.Push) { item.Update(UpdateTypes.AToB); } else if (action == Actions.Delete) { item.Update(UpdateTypes.Delete); } }
private static bool CheckEnabled(string action, DiffItem item) { if (action == Actions.Push) { return(item.Condition == DiffConditions.AOnly || item.Condition == DiffConditions.Different); } else if (action == Actions.Delete) { return(item.Condition == DiffConditions.BOnly); } return(true); }
public List <DiffItem> findDifferences(int currentStateId) { Dictionary <string, FileItem> dict0 = getFiles(currentStateId - 1); Dictionary <string, FileItem> dict1 = getFiles(currentStateId); HashSet <string> deletedTopFolders = findDeletedTopFolders(dict0, dict1); List <DiffItem> ret = new List <DiffItem>(); foreach (FileItem oldItem in dict0.Values) { if (dict1.ContainsKey(oldItem.FullPath)) { var newItem = dict1.GetValueOrDefault(oldItem.FullPath); if (areDifferent(oldItem, newItem)) { DiffItem diff1 = DiffItem.modified(newItem.FullPath, newItem.LastUpdated, newItem.Size); ret.Add(diff1); continue; } continue; } if (isTopLevelFolder(oldItem, deletedTopFolders)) { DiffItem diff2 = DiffItem.deletedRecursively(oldItem.FullPath); ret.Add(diff2); continue; } if (isDescendantOf(oldItem.FullPath, deletedTopFolders)) { continue; } DiffItem diff3 = DiffItem.deleted(oldItem.FullPath); ret.Add(diff3); } foreach (FileItem newItem in dict1.Values) { if (!dict0.ContainsKey(newItem.FullPath)) { DiffItem diff3 = DiffItem.created(newItem.FullPath, newItem.LastUpdated, newItem.Size); ret.Add(diff3); continue; } } return(ret); }
public DiffItemDTO MapFrom(DiffItem diffItem) { _diffItemDTO = new DiffItemDTO { Description = diffItem.Description }; try { this.Visit(diffItem); return(_diffItemDTO); } finally { _diffItemDTO = null; } }
private static void ComparePackages(ApiAssembly olda, ApiAssembly newa) { List <ApiBaseItem> allOld = GetAllItems(olda); ApiNamespace[] oldNss = GetNamespaces(allOld, 1); List <ApiBaseItem> allNew = GetAllItems(newa); ApiNamespace[] newNss = GetNamespaces(allNew, 1); List <DiffItem> diffs = CompareItems(oldNss, newNss).ToList(); DiffItem parentDiff = new DiffItem { DiffType = DiffType.Changed, Children = diffs, Item = new ApiRoot() }; LogDiffs(parentDiff, ""); }
protected override void Context() { base.Context(); _diffItem1 = new PropertyValueDiffItem(); _diffItem2 = new PropertyValueDiffItem(); _dto1 = new DiffItemDTO(); _dto2 = new DiffItemDTO(); _dto1.PathElements[PathElementId.Name] = new PathElement { DisplayName = "A" }; _dto2.PathElements[PathElementId.Name] = new PathElement { DisplayName = "B" }; _dto1.PathElements[PathElementId.Molecule] = new PathElement { DisplayName = "Mol" }; _dto2.PathElements[PathElementId.Molecule] = new PathElement { DisplayName = "Mol2" }; _dto1.PathElements[PathElementId.TopContainer] = new PathElement { DisplayName = "A" }; _dto2.PathElements[PathElementId.TopContainer] = new PathElement { DisplayName = "A" }; _dto1.PathElements[PathElementId.BottomCompartment] = new PathElement { DisplayName = "" }; _dto2.PathElements[PathElementId.BottomCompartment] = new PathElement { DisplayName = "" }; _report.Add(_diffItem1); _report.Add(_diffItem2); A.CallTo(() => _diffItemDTOMapper.MapFrom(_diffItem1)).Returns(_dto1); A.CallTo(() => _diffItemDTOMapper.MapFrom(_diffItem2)).Returns(_dto2); A.CallTo(() => _view.BindTo(A <IEnumerable <DiffItemDTO> > ._)) .Invokes(x => _allDiffItemDTO = x.GetArgument <IEnumerable <DiffItemDTO> >(0).ToList()); }
private static void LogDiffs(DiffItem parentDiff, string prefix) { IWriter writer = GetWriter(parentDiff); if (writer == null) { return; } Log($"{prefix}{writer.GetPrefix()}"); if (writer.Expandable) { foreach (DiffItem diff in parentDiff.Children) { LogDiffs(diff, prefix + Prefix); } } Log($"{prefix}{writer.GetSuffix()}"); }
static DiffItem[] CreateDiffs(DiffData diffDataA, DiffData diffDataB) { var list = new List <DiffItem>(); DiffItem item; int startA, startB; int lineA, lineB; lineA = 0; lineB = 0; while (lineA < diffDataA.Length || lineB < diffDataB.Length) { if ((lineA < diffDataA.Length) && (!diffDataA.modified[lineA]) && (lineB < diffDataB.Length) && (!diffDataB.modified[lineB])) { lineA++; lineB++; } else { startA = lineA; startB = lineB; while (lineA < diffDataA.Length && (lineB >= diffDataB.Length || diffDataA.modified[lineA])) { lineA++; } while (lineB < diffDataB.Length && (lineA >= diffDataA.Length || diffDataB.modified[lineB])) { lineB++; } if ((startA < lineA) || (startB < lineB)) { item = new DiffItem(); item.StartA = startA; item.StartB = startB; item.DeletedA = lineA - startA; item.InsertedB = lineB - startB; list.Add(item); } } } return(list.ToArray()); }
private static IWriter GetWriter(DiffItem diffItem) { if (diffItem.Item is ApiRoot) { return(new ApiRootWriter(diffItem, diffTitle)); } if (diffItem.Item is ApiNamespace) { return(new ApiNamespaceWriter(diffItem)); } if (diffItem.Item is IApiType) { bool logDetail = DetailedDetailLog && (DetailedRemovedLog || diffItem.DiffType != DiffType.Removed) && diffItem.Children.Any(); return(new ApiTypeWriter(diffItem, logDetail)); } if (diffItem.Item is IDetail) { return(new ApiMemberWriter(diffItem)); } return(null); }
public ShowDiffWindow(string oldScript, string newScript) { InitializeComponent(); List <DiffItem> diffItems = Diff.DiffTexts(oldScript, newScript); for (int i = 0; i < diffItems.Count; i++) { DiffItem diffItem = diffItems[i]; BrushConverter bc = new BrushConverter(); TextRange tr = new TextRange(scriptText.Document.ContentEnd, scriptText.Document.ContentEnd) { Text = diffItem.data + Environment.NewLine }; if (diffItem.type == "Deleted") { tr.ApplyPropertyValue(TextElement.BackgroundProperty, "#FFF8FF"); } else if (diffItem.type == "Inserted") { tr.ApplyPropertyValue(TextElement.BackgroundProperty, "#F8FFF8"); } } }
public ApiMemberWriter(DiffItem item) { _item = item; _detail = (item.Item as IDetail) !; }
protected override void Context() { base.Context(); _diffItem = new PropertyValueDiffItem(); }
private string ancestorDisplayName(DiffItem propertyDiffItem) { return(_displayNameProvider.DisplayNameFor(propertyDiffItem.CommonAncestor)); }
private string ancestorDisplayName(DiffItem propertyDiffItem) => displayNameFor(propertyDiffItem.CommonAncestor);
/// <summary> /// Generates a sequence of DiffItems representing differences in rawDiffStream. /// </summary> /// <param name="includeUnchangedBlocks"> /// Indicates whether to generate DiffItems for unchanged blocks. /// </param> /// <returns>A DiffItem generator.</returns> public static IEnumerable<DiffItem> EnumerateDifferences( StreamCombiner rawDiffStream, bool includeUnchangedBlocks) { DiffItem prevItem = null; DiffItem item = null; string line = null; do { line = rawDiffStream == null ? null : rawDiffStream.ReadLine(); if (line != null && line.StartsWith("<")) { ++item.BaseLineCount; } else if (line != null && line.StartsWith("-")) { continue; } else if (line != null && line.StartsWith(">")) { ++item.DiffLineCount; } else if (line != null && line.Equals("\\ No newline at end of file")) { // This is a very annoying perforce thing. But we have to account for it. continue; } else { if (item != null) { if (item.DiffLineCount == 0) item.DiffType = DiffType.Deleted; else if (item.BaseLineCount == 0) item.DiffType = DiffType.Added; else item.DiffType = DiffType.Changed; yield return item; prevItem = item; item = null; } if (line != null) { item = new DiffItem(); Match m = DiffDecoder.Match(line); if (!m.Success) yield break; item.BaseStartLineNumber = Int32.Parse(m.Groups[1].Value); // 'a' adds AFTER the line, but we do processing once we get to the line. // So we need to really get to the next line. if (m.Groups[3].Value.Equals("a")) item.BaseStartLineNumber += 1; } if (includeUnchangedBlocks) { var unchangedItem = new DiffItem(); unchangedItem.DiffType = DiffType.Unchanged; unchangedItem.BaseStartLineNumber = prevItem == null ? 1 : prevItem.BaseStartLineNumber + prevItem.BaseLineCount; unchangedItem.BaseLineCount = item == null ? int.MaxValue : item.BaseStartLineNumber - unchangedItem.BaseStartLineNumber; unchangedItem.DiffLineCount = unchangedItem.BaseLineCount; if (unchangedItem.BaseLineCount != 0) yield return unchangedItem; } } } while (line != null); }
public ApiTypeWriter(DiffItem item, bool expandable) { this.item = item; Expandable = expandable; api = item.Item as IApiType; }
public ApiMemberWriter(DiffItem item) { this.item = item; this.detail = item.Item as IDetail; }
public ApiNamespaceWriter(DiffItem item) { this.item = item; ns = item.Item as ApiNamespace; }
public ApiRootWriter(DiffItem item, string title) { this.item = item; this.title = title; this.api = item.Item as ApiNamespace; }
private string displayIf <T>(DiffItem propertyDiffItem, Func <T, string> displayFunc) where T : class { var castObject = propertyDiffItem.Object1 as T; return(castObject == null ? null : displayFunc(castObject)); }
public ApiTypeWriter(DiffItem item, bool expandable) { _item = item; Expandable = expandable; _api = (item.Item as IApiType) !; }
public ApiNamespaceWriter(DiffItem item) { _item = item; _ns = (item.Item as ApiNamespace) !; }
private DiffItemDTO mapFrom(DiffItem diffItem) { return(_diffItemDTOMapper.MapFrom(diffItem)); }
public void Add(DiffItem diffItem) { Report.Add(diffItem); }