/** * @return the {@link RevObject.TYPE} of the new object, or {@code null} if there isn't one */ public TYPE newObjectType() { NodeRef newObject = getNewObject(); return newObject != null ? newObject.getType() : null; }
/** * @return the metadata {@link ObjectId} of the new object, or {@link ObjectId#NULL} if there * isn't one */ public ObjectId newMetadataId() { NodeRef newObject = getNewObject(); return newObject != null ? newObject.getMetadataId() : ObjectId.NULL; }
public void writeDiff(DiffEntry diff, DataOutput data) throws IOException { if (diff.getOldObject() == null) { data.writeBoolean(false); } else { data.writeBoolean(true); writeNodeRef(diff.getOldObject(), data); } if (diff.getNewObject() == null) { data.writeBoolean(false); } else { data.writeBoolean(true); writeNodeRef(diff.getNewObject(), data); } }
public static void writeDiff(DiffEntry diff, DataOutput data) throws IOException { if (diff.getOldObject() == null) { data.writeBoolean(false); } else { data.writeBoolean(true); writeNodeRef(diff.getOldObject(), data); } if (diff.getNewObject() == null) { data.writeBoolean(false); } else { data.writeBoolean(true); writeNodeRef(diff.getNewObject(), data); } }
@Override public void write(DataOutputStream out, DiffEntry e) throws IOException { @Nullable NodeRef left = e.getOldObject(); @Nullable NodeRef right = e.getNewObject(); write(out, left); write(out, right); }
private void checkForFeatureTypeConflict(Optional<NodeRef> ancestorVersion, DiffEntry oursDiff, DiffEntry theirsDiff, MergeScenarioReport report) { final String path = oursDiff.path(); final boolean featureTypeConflict = !theirsDiff.getNewObject().getMetadataId() .equals(oursDiff.getNewObject().getMetadataId()); if (featureTypeConflict) { // In this case, we store the metadata id, not the element id ObjectId ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion.get().getMetadataId() : ObjectId.NULL; ObjectId ours = oursDiff.getNewObject().getMetadataId(); ObjectId theirs = theirsDiff.getNewObject().getMetadataId(); consumer.conflicted(new Conflict(path, ancestorVersionId, ours, theirs)); report.addConflict(); } } }
public void addAlteredTree(DiffEntry diff) { ObjectId oldFeatureType = diff.getOldObject() == null ? null : diff.getOldObject().getMetadataId(); ObjectId newFeatureType = diff.getNewObject() == null ? null : diff.getNewObject().getMetadataId(); String path = diff.oldPath() == null ? diff.newPath() : diff.oldPath(); alteredTrees.add(new FeatureTypeDiff(path, oldFeatureType, newFeatureType)); }
public Feature[] getUnstagedFeatures(String path, boolean noDeletions) { List<Feature> list = Lists.newArrayList(); try (AutoCloseableIterator<DiffEntry> diffs = repository.workingTree().getUnstaged(path)) { while (diffs.hasNext()) { DiffEntry diff = diffs.next(); if (!diff.changeType().equals(ChangeType.REMOVED) || !noDeletions) { RevFeature revFeature = repository.command(RevObjectParse.class) .setObjectId(diff.newObjectId()).call(RevFeature.class).get(); RevFeatureType revFeatureType = repository.command(RevObjectParse.class) .setObjectId(diff.getNewObject().getMetadataId()) .call(RevFeatureType.class).get(); FeatureBuilder builder = new FeatureBuilder(revFeatureType); list.add(builder.build(diff.getNewObject().name(), revFeature)); } } } return list.toArray(new Feature[0]); }
private static String formatPath(DiffEntry entry) { String path; NodeRef oldObject = entry.getOldObject(); NodeRef newObject = entry.getNewObject(); if (oldObject == null) { path = newObject.path(); } else if (newObject == null) { path = oldObject.path(); } else { if (oldObject.path().equals(newObject.path())) { path = oldObject.path(); } else { path = oldObject.path() + " -> " + newObject.path(); } } return path; }
/** * Formats a DiffEntry for display * * @param entry the DiffEntry to format * @return the formatted display string * @see DiffEntry */ private String formatPath(DiffEntry entry) { String path; NodeRef oldObject = entry.getOldObject(); NodeRef newObject = entry.getNewObject(); if (oldObject == null) { path = newObject.path(); } else if (newObject == null) { path = oldObject.path(); } else { if (oldObject.path().equals(newObject.path())) { path = oldObject.path(); } else { path = oldObject.path() + " -> " + newObject.path(); } } return path; } }
NodeRef nodeRef = old ? de.getOldObject() : de.getNewObject(); if (nodeRef == null) { return null;
@Test public void testAddNewPathUsingPathFilter() throws Exception { insert(points1); insert(points2); geogig.command(AddOp.class).addPattern("Points/Points.1").call(); List<DiffEntry> unstaged = toList(repo.index().getStaged(null)); assertEquals(unstaged.toString(), 2, unstaged.size()); assertEquals(ChangeType.ADDED, unstaged.get(0).changeType()); assertEquals(RevObject.TYPE.TREE, unstaged.get(0).getNewObject().getType()); assertEquals("Points", unstaged.get(0).newName()); RevFeatureType ft = RevFeatureTypeBuilder.build(pointsType); ObjectId expectedTreeMdId = ft.getId(); assertEquals(expectedTreeMdId, unstaged.get(0).getNewObject().getMetadataId()); assertEquals(ChangeType.ADDED, unstaged.get(1).changeType()); assertEquals(RevObject.TYPE.FEATURE, unstaged.get(1).getNewObject().getType()); assertEquals("Points.1", unstaged.get(1).newName()); assertFalse("feature node's metadata id should not be set, as it uses the parent tree one", unstaged.get(1).getNewObject().getNode().getMetadataId().isPresent()); }
/** * @return the next {@link DiffEntry} */ private DiffEntry computeNext() { if (source.hasNext()) { DiffEntry next = source.next(); if (next.getNewObject() != null) { NodeRef newObject = next.getNewObject(); RevObject object = sourceRepo.command(RevObjectParse.class) .setObjectId(newObject.getNode().getObjectId()).call().get(); RevObject metadata = null; if (newObject.getMetadataId() != ObjectId.NULL) { metadata = sourceRepo.command(RevObjectParse.class) .setObjectId(newObject.getMetadataId()).call().get(); } if (!destinationRepo.blobExists(object.getId())) { destinationRepo.objectDatabase().put(object); } if (metadata != null && !destinationRepo.blobExists(metadata.getId())) { destinationRepo.objectDatabase().put(metadata); } } return next; } return null; } }
@Test public void testTreeModifiedByAddingExtraFeature() throws Exception { insertAndAdd(points1, points2); insert(points3); List<DiffEntry> difflist = toList(diffOp.setReportTrees(true).call()); assertNotNull(difflist); assertEquals(2, difflist.size()); assertEquals(ChangeType.MODIFIED, difflist.get(0).changeType()); assertEquals(TYPE.TREE, difflist.get(0).getOldObject().getType()); assertEquals(ChangeType.ADDED, difflist.get(1).changeType()); assertEquals(TYPE.FEATURE, difflist.get(1).getNewObject().getType()); }
@Test public void testAddMultipleFeaturesWithPathFilter() throws Exception { insert(points1); insert(points2); insert(lines1); geogig.command(AddOp.class).addPattern("Points").call(); List<DiffEntry> unstaged = toList(repo.workingTree().getUnstaged(null)); assertEquals(2, unstaged.size()); assertEquals(linesName, unstaged.get(0).newName()); assertEquals(ChangeType.ADDED, unstaged.get(0).changeType()); assertEquals(TYPE.TREE, unstaged.get(0).getNewObject().getType()); }
@Test public void testReportTreesEmptyTreeFromFeatureDeletion() throws Exception { insert(lines1); delete(lines1); List<DiffEntry> difflist = toList(diffOp.setReportTrees(true).setOldVersion(ObjectId.NULL) .setNewVersion(Ref.WORK_HEAD).call()); assertNotNull(difflist); assertEquals(1, difflist.size()); assertEquals(linesName, difflist.get(0).newName()); DiffEntry de = difflist.get(0); assertNull(de.getOldObject()); assertNotNull(de.getNewObject()); assertEquals(linesName, de.newPath()); assertEquals(DiffEntry.ChangeType.ADDED, de.changeType()); assertEquals(ObjectId.NULL, de.oldObjectId()); assertFalse(de.getNewObject().getMetadataId().isNull()); }
@Test public void testReportTreesEmptyTree() throws Exception { WorkingTree workingTree = geogig.getRepository().workingTree(); workingTree.createTypeTree(linesName, linesType); List<DiffEntry> difflist = toList(diffOp.setReportTrees(true).setOldVersion(ObjectId.NULL) .setNewVersion(Ref.WORK_HEAD).call()); assertNotNull(difflist); assertEquals(1, difflist.size()); DiffEntry de = difflist.get(0); assertNull(de.getOldObject()); assertNotNull(de.getNewObject()); assertEquals(linesName, de.newPath()); assertEquals(DiffEntry.ChangeType.ADDED, de.changeType()); assertEquals(ObjectId.NULL, de.oldObjectId()); assertFalse(de.getNewObject().getMetadataId().isNull()); }
@Test public void testSingleAddition() throws Exception { final ObjectId newOid = insertAndAdd(points1); geogig.command(CommitOp.class).setAll(true).call(); List<DiffEntry> difflist = toList( diffOp.setOldVersion(ObjectId.NULL).setNewVersion(Ref.HEAD).call()); assertNotNull(difflist); assertEquals(1, difflist.size()); DiffEntry de = difflist.get(0); assertNull(de.getOldObject()); assertNotNull(de.getNewObject()); String expectedPath = NodeRef.appendChild(pointsName, points1.getIdentifier().getID()); assertEquals(expectedPath, de.newPath()); assertEquals(DiffEntry.ChangeType.ADDED, de.changeType()); assertEquals(ObjectId.NULL, de.oldObjectId()); assertEquals(newOid, de.newObjectId()); assertFalse(de.getNewObject().getMetadataId().isNull()); }
@Override public void print(GeoGIG geogig, Console console, DiffEntry entry) throws IOException { Ansi ansi = AnsiDecorator.newAnsi(console.isAnsiSupported()); final NodeRef newObject = entry.getNewObject(); final NodeRef oldObject = entry.getOldObject(); String oldMode = shortOid(oldObject == null ? ObjectId.NULL : oldObject.getMetadataId()); String newMode = shortOid(newObject == null ? ObjectId.NULL : newObject.getMetadataId()); String oldId = shortOid(oldObject == null ? ObjectId.NULL : oldObject.getObjectId()); String newId = shortOid(newObject == null ? ObjectId.NULL : newObject.getObjectId()); ansi.a(oldMode).a(" "); ansi.a(newMode).a(" "); ansi.a(oldId).a(" "); ansi.a(newId).a(" "); ansi.fg(entry.changeType() == ADDED ? GREEN : (entry.changeType() == MODIFIED ? YELLOW : RED)); char type = entry.changeType().toString().charAt(0); ansi.a(" ").a(type).reset(); ansi.a(" ").a(formatPath(entry)); console.println(ansi.toString()); }
@Test public void testSingleAdditionReverseOrder() throws Exception { final ObjectId newOid = insertAndAdd(points1); final RevCommit commit = geogig.command(CommitOp.class).setAll(true).call(); List<DiffEntry> difflist = toList( diffOp.setOldVersion(commit.getId()).setNewVersion(ObjectId.NULL).call()); assertNotNull(difflist); assertEquals(1, difflist.size()); DiffEntry de = difflist.get(0); assertNull(de.getNewObject()); assertNotNull(de.getOldObject()); assertEquals(DiffEntry.ChangeType.REMOVED, de.changeType()); assertEquals(ObjectId.NULL, de.newObjectId()); assertEquals(newOid, de.oldObjectId()); assertFalse(de.getOldObject().getMetadataId().isNull()); }