ObjectWalk: make setRetainBody(false) the default

Despite being the primary author of RevWalk and ObjectWalk I still
fail to remember to setRetainBody(false) in application code using
an ObjectWalk to examine the graph.

Document the default for RevWalk is setRetainBody(true), where the
application usually wants the commit bodies to display or inspect.

Change the default for ObjectWalk to setRetainBody(false), as nearly
all callers want only the graph shape and do not need the larger text
inside a commit body. This allows some code in JGit to be simplified.

Change-Id: I367e42209e805bd5e1f41b4072aeb2fa98ec9d99

org.eclipse.jgit.test/tst/org/eclipse/jgit/revwalk/FooterLineTest.java

@@ -360,10 +360,10 @@ public class FooterLineTest extends RepositoryTestCase {
 		buf.append("\n");
 		buf.append(msg);
 
-		final RevWalk walk = new RevWalk(db);
-		walk.setRetainBody(true);
-		final RevCommit c = new RevCommit(ObjectId.zeroId());
-		c.parseCanonical(walk, Constants.encode(buf.toString()));
-		return c;
+		try (RevWalk walk = new RevWalk(db)) {
+			RevCommit c = new RevCommit(ObjectId.zeroId());
+			c.parseCanonical(walk, Constants.encode(buf.toString()));
+			return c;
+		}
 	}
 }

org.eclipse.jgit/src/org/eclipse/jgit/api/StashCreateCommand.java

@@ -188,7 +188,6 @@ public class StashCreateCommand extends GitCommand<RevCommit> {
 	private RevCommit parseCommit(final ObjectReader reader,
 			final ObjectId headId) throws IOException {
 		final RevWalk walk = new RevWalk(reader);
-		walk.setRetainBody(true);
 		return walk.parseCommit(headId);
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/StashListCommand.java

@@ -96,10 +96,8 @@ public class StashListCommand extends GitCommand<Collection<RevCommit>> {
 
 		final List<RevCommit> stashCommits = new ArrayList<RevCommit>(
 				stashEntries.size());
-		final RevWalk walk = new RevWalk(repo);
-		walk.setRetainBody(true);
-		try {
-			for (ReflogEntry entry : stashEntries)
+		try (RevWalk walk = new RevWalk(repo)) {
+			for (ReflogEntry entry : stashEntries) {
 				try {
 					stashCommits.add(walk.parseCommit(entry.getNewId()));
 				} catch (IOException e) {
@@ -107,8 +105,7 @@ public class StashListCommand extends GitCommand<Collection<RevCommit>> {
 							JGitText.get().cannotReadCommit, entry.getNewId()),
 							e);
 				}
-		} finally {
-			walk.dispose();
+			}
 		}
 		return stashCommits;
 	}

org.eclipse.jgit/src/org/eclipse/jgit/blame/BlameGenerator.java

@@ -179,7 +179,6 @@ public class BlameGenerator implements AutoCloseable {
 		else
 			revPool = new RevWalk(getRepository());
 
-		revPool.setRetainBody(true);
 		SEEN = revPool.newFlag("SEEN"); //$NON-NLS-1$
 		reader = revPool.getObjectReader();
 		treeWalk = new TreeWalk(reader);

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/PackWriter.java

@@ -1587,8 +1587,6 @@ public class PackWriter implements AutoCloseable {
 		stats.interestingObjects = Collections.unmodifiableSet(new HashSet<ObjectId>(want));
 		stats.uninterestingObjects = Collections.unmodifiableSet(new HashSet<ObjectId>(have));
 
-		walker.setRetainBody(false);
-
 		canBuildBitmaps = config.isBuildBitmaps()
 				&& !shallowPack
 				&& have.isEmpty()

org.eclipse.jgit/src/org/eclipse/jgit/revwalk/ObjectWalk.java

@@ -133,6 +133,7 @@ public class ObjectWalk extends RevWalk {
 	 */
 	public ObjectWalk(ObjectReader or) {
 		super(or);
+		setRetainBody(false);
 		rootObjects = new ArrayList<RevObject>();
 		pendingObjects = new BlockObjQueue();
 		pathBuf = new byte[256];

org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevCommit.java

@@ -92,29 +92,34 @@ public class RevCommit extends RevObject {
 
 	/**
 	 * Parse a commit from its canonical format.
-	 *
+	 * <p>
 	 * This method inserts the commit directly into the caller supplied revision
 	 * pool, making it appear as though the commit exists in the repository,
 	 * even if it doesn't. The repository under the pool is not affected.
+	 * <p>
+	 * The body of the commit (message, author, committer) is always retained in
+	 * the returned {@code RevCommit}, even if the supplied {@code RevWalk} has
+	 * been configured with {@code setRetainBody(false)}.
 	 *
 	 * @param rw
 	 *            the revision pool to allocate the commit within. The commit's
 	 *            tree and parent pointers will be obtained from this pool.
 	 * @param raw
-	 *            the canonical formatted commit to be parsed.
+	 *            the canonical formatted commit to be parsed. This buffer will
+	 *            be retained by the returned {@code RevCommit} and must not be
+	 *            modified by the caller.
 	 * @return the parsed commit, in an isolated revision pool that is not
 	 *         available to the caller.
 	 * @throws IOException
 	 *             in case of RevWalk initialization fails
 	 */
 	public static RevCommit parse(RevWalk rw, byte[] raw) throws IOException {
-		ObjectInserter.Formatter fmt = new ObjectInserter.Formatter();
-		boolean retain = rw.isRetainBody();
-		rw.setRetainBody(true);
-		RevCommit r = rw.lookupCommit(fmt.idFor(Constants.OBJ_COMMIT, raw));
-		r.parseCanonical(rw, raw);
-		rw.setRetainBody(retain);
-		return r;
+		try (ObjectInserter.Formatter fmt = new ObjectInserter.Formatter()) {
+			RevCommit r = rw.lookupCommit(fmt.idFor(Constants.OBJ_COMMIT, raw));
+			r.parseCanonical(rw, raw);
+			r.buffer = raw;
+			return r;
+		}
 	}
 
 	static final RevCommit[] NO_PARENTS = {};

org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevTag.java

@@ -87,16 +87,22 @@ public class RevTag extends RevObject {
 
 	/**
 	 * Parse an annotated tag from its canonical format.
-	 *
+	 * <p>
 	 * This method inserts the tag directly into the caller supplied revision
 	 * pool, making it appear as though the tag exists in the repository, even
 	 * if it doesn't. The repository under the pool is not affected.
+	 * <p>
+	 * The body of the tag (message, tagger, signature) is always retained in
+	 * the returned {@code RevTag}, even if the supplied {@code RevWalk} has
+	 * been configured with {@code setRetainBody(false)}.
 	 *
 	 * @param rw
 	 *            the revision pool to allocate the tag within. The tag's object
 	 *            pointer will be obtained from this pool.
 	 * @param raw
-	 *            the canonical formatted tag to be parsed.
+	 *            the canonical formatted tag to be parsed. This buffer will be
+	 *            retained by the returned {@code RevTag} and must not be
+	 *            modified by the caller.
 	 * @return the parsed tag, in an isolated revision pool that is not
 	 *         available to the caller.
 	 * @throws CorruptObjectException
@@ -104,13 +110,12 @@ public class RevTag extends RevObject {
 	 */
 	public static RevTag parse(RevWalk rw, byte[] raw)
 			throws CorruptObjectException {
-		ObjectInserter.Formatter fmt = new ObjectInserter.Formatter();
-		boolean retain = rw.isRetainBody();
-		rw.setRetainBody(true);
-		RevTag r = rw.lookupTag(fmt.idFor(Constants.OBJ_TAG, raw));
-		r.parseCanonical(rw, raw);
-		rw.setRetainBody(retain);
-		return r;
+		try (ObjectInserter.Formatter fmt = new ObjectInserter.Formatter()) {
+			RevTag r = rw.lookupTag(fmt.idFor(Constants.OBJ_TAG, raw));
+			r.parseCanonical(rw, raw);
+			r.buffer = raw;
+			return r;
+		}
 	}
 
 	private RevObject object;

org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevWalk.java

@@ -192,7 +192,7 @@ public class RevWalk implements Iterable<RevCommit>, AutoCloseable {
 
 	private TreeFilter treeFilter;
 
-	private boolean retainBody;
+	private boolean retainBody = true;
 
 	private boolean rewriteParents = true;
 
@@ -233,7 +233,6 @@ public class RevWalk implements Iterable<RevCommit>, AutoCloseable {
 		sorting = EnumSet.of(RevSort.NONE);
 		filter = RevFilter.ALL;
 		treeFilter = TreeFilter.ALL;
-		retainBody = true;
 		this.closeReader = closeReader;
 	}
 
@@ -607,6 +606,9 @@ public class RevWalk implements Iterable<RevCommit>, AutoCloseable {
 	 * Usually the body is always retained, but some application code might not
 	 * care and would prefer to discard the body of a commit as early as
 	 * possible, to reduce memory usage.
+	 * <p>
+	 * True by default on {@link RevWalk} and false by default for
+	 * {@link ObjectWalk}.
 	 *
 	 * @return true if the body should be retained; false it is discarded.
 	 */
@@ -620,6 +622,9 @@ public class RevWalk implements Iterable<RevCommit>, AutoCloseable {
 	 * If a body of a commit or tag is not retained, the application must
 	 * call {@link #parseBody(RevObject)} before the body can be safely
 	 * accessed through the type specific access methods.
+	 * <p>
+	 * True by default on {@link RevWalk} and false by default for
+	 * {@link ObjectWalk}.
 	 *
 	 * @param retain true to retain bodies; false to discard them early.
 	 */

org.eclipse.jgit/src/org/eclipse/jgit/transport/BaseReceivePack.java

@@ -1143,7 +1143,6 @@ public abstract class BaseReceivePack {
 		parser = null;
 
 		try (final ObjectWalk ow = new ObjectWalk(db)) {
-			ow.setRetainBody(false);
 			if (baseObjects != null) {
 				ow.sort(RevSort.TOPO);
 				if (!baseObjects.isEmpty())