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

 		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

 	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

 
 		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) {
 							JGitText.get().cannotReadCommit, entry.getNewId()),
 							e);
 				}
-		} finally {
-			walk.dispose();
+			}
 		}
 		return stashCommits;
 	}

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

 		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

 		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

 	 */
 	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

 
 	/**
 	 * 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

 
 	/**
 	 * 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
 	 */
 	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

 
 	private TreeFilter treeFilter;
 
-	private boolean retainBody;
+	private boolean retainBody = true;
 
 	private boolean rewriteParents = true;
 
 		sorting = EnumSet.of(RevSort.NONE);
 		filter = RevFilter.ALL;
 		treeFilter = TreeFilter.ALL;
-		retainBody = true;
 		this.closeReader = closeReader;
 	}
 
 	 * 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.
 	 */
 	 * 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

 		parser = null;
 
 		try (final ObjectWalk ow = new ObjectWalk(db)) {
-			ow.setRetainBody(false);
 			if (baseObjects != null) {
 				ow.sort(RevSort.TOPO);
 				if (!baseObjects.isEmpty())