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

   1 /*
   2  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
   3  *
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or
   7  * without modification, are permitted provided that the following
   8  * conditions are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  *
  13  * - Redistributions in binary form must reproduce the above
  14  *   copyright notice, this list of conditions and the following
  15  *   disclaimer in the documentation and/or other materials provided
  16  *   with the distribution.
  17  *
  18  * - Neither the name of the Git Development Community nor the
  19  *   names of its contributors may be used to endorse or promote
  20  *   products derived from this software without specific prior
  21  *   written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  24  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  25  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  28  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  33  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  35  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 package org.spearce.jgit.revwalk;
  39
  40 import java.io.IOException;
  41 import java.nio.charset.Charset;
  42
  43 import org.spearce.jgit.errors.IncorrectObjectTypeException;
  44 import org.spearce.jgit.errors.MissingObjectException;
  45 import org.spearce.jgit.lib.AnyObjectId;
  46 import org.spearce.jgit.lib.Commit;
  47 import org.spearce.jgit.lib.Constants;
  48 import org.spearce.jgit.lib.MutableObjectId;
  49 import org.spearce.jgit.lib.ObjectLoader;
  50 import org.spearce.jgit.lib.PersonIdent;
  51 import org.spearce.jgit.util.RawParseUtils;
  52
  53 /** A commit reference to a commit in the DAG. */
  54 public class RevCommit extends RevObject {
  55         static final RevCommit[] NO_PARENTS = {};
  56
  57         private static final String TYPE_COMMIT = Constants.TYPE_COMMIT;
  58
  59         private RevTree tree;
  60
  61         RevCommit[] parents;
  62
  63         int commitTime;
  64
  65         int inDegree;
  66
  67         private byte[] buffer;
  68
  69         /**
  70          * Create a new commit reference.
  71          *
  72          * @param id
  73          *            object name for the commit.
  74          */
  75         protected RevCommit(final AnyObjectId id) {
  76                 super(id);
  77         }
  78
  79         @Override
  80         void parse(final RevWalk walk) throws MissingObjectException,
  81                         IncorrectObjectTypeException, IOException {
  82                 final ObjectLoader ldr = walk.db.openObject(walk.curs, this);
  83                 if (ldr == null)
  84                         throw new MissingObjectException(this, TYPE_COMMIT);
  85                 final byte[] data = ldr.getCachedBytes();
  86                 if (Constants.OBJ_COMMIT != ldr.getType())
  87                         throw new IncorrectObjectTypeException(this, TYPE_COMMIT);
  88                 parseCanonical(walk, data);
  89         }
  90
  91         void parseCanonical(final RevWalk walk, final byte[] raw) {
  92                 final MutableObjectId idBuffer = walk.idBuffer;
  93                 idBuffer.fromString(raw, 5);
  94                 tree = walk.lookupTree(idBuffer);
  95
  96                 int ptr = 46;
  97                 if (parents == null) {
  98                         RevCommit[] pList = new RevCommit[1];
  99                         int nParents = 0;
 100                         for (;;) {
 101                                 if (raw[ptr] != 'p')
 102                                         break;
 103                                 idBuffer.fromString(raw, ptr + 7);
 104                                 final RevCommit p = walk.lookupCommit(idBuffer);
 105                                 if (nParents == 0)
 106                                         pList[nParents++] = p;
 107                                 else if (nParents == 1) {
 108                                         pList = new RevCommit[] { pList[0], p };
 109                                         nParents = 2;
 110                                 } else {
 111                                         if (pList.length <= nParents) {
 112                                                 RevCommit[] old = pList;
 113                                                 pList = new RevCommit[pList.length + 32];
 114                                                 System.arraycopy(old, 0, pList, 0, nParents);
 115                                         }
 116                                         pList[nParents++] = p;
 117                                 }
 118                                 ptr += 48;
 119                         }
 120                         if (nParents != pList.length) {
 121                                 RevCommit[] old = pList;
 122                                 pList = new RevCommit[nParents];
 123                                 System.arraycopy(old, 0, pList, 0, nParents);
 124                         }
 125                         parents = pList;
 126                 }
 127
 128                 // extract time from "committer "
 129                 ptr = RawParseUtils.committer(raw, ptr);
 130                 if (ptr > 0) {
 131                         ptr = RawParseUtils.nextLF(raw, ptr, '>');
 132                         commitTime = RawParseUtils.parseBase10(raw, ptr, null);
 133                 }
 134
 135                 buffer = raw;
 136                 flags |= PARSED;
 137         }
 138
 139         static void carryFlags(RevCommit c, final int carry) {
 140                 for (;;) {
 141                         final RevCommit[] pList = c.parents;
 142                         if (pList == null)
 143                                 return;
 144                         final int n = pList.length;
 145                         if (n == 0)
 146                                 return;
 147
 148                         for (int i = 1; i < n; i++) {
 149                                 final RevCommit p = pList[i];
 150                                 if ((p.flags & carry) == carry)
 151                                         continue;
 152                                 p.flags |= carry;
 153                                 carryFlags(p, carry);
 154                         }
 155
 156                         c = pList[0];
 157                         if ((c.flags & carry) == carry)
 158                                 return;
 159                         c.flags |= carry;
 160                 }
 161         }
 162
 163         /**
 164          * Carry a RevFlag set on this commit to its parents.
 165          * <p>
 166          * If this commit is parsed, has parents, and has the supplied flag set on
 167          * it we automatically add it to the parents, grand-parents, and so on until
 168          * an unparsed commit or a commit with no parents is discovered. This
 169          * permits applications to force a flag through the history chain when
 170          * necessary.
 171          *
 172          * @param flag
 173          *            the single flag value to carry back onto parents.
 174          */
 175         public void carry(final RevFlag flag) {
 176                 final int carry = flags & flag.mask;
 177                 if (carry != 0)
 178                         carryFlags(this, carry);
 179         }
 180
 181         /**
 182          * Time from the "committer " line of the buffer.
 183          *
 184          * @return time, expressed as seconds since the epoch.
 185          */
 186         public final int getCommitTime() {
 187                 return commitTime;
 188         }
 189
 190         /**
 191          * Parse this commit buffer for display.
 192          *
 193          * @param walk
 194          *            revision walker owning this reference.
 195          * @return parsed commit.
 196          */
 197         public final Commit asCommit(final RevWalk walk) {
 198                 return new Commit(walk.db, this, buffer);
 199         }
 200
 201         /**
 202          * Get a reference to this commit's tree.
 203          *
 204          * @return tree of this commit.
 205          */
 206         public final RevTree getTree() {
 207                 return tree;
 208         }
 209
 210         /**
 211          * Get the number of parent commits listed in this commit.
 212          *
 213          * @return number of parents; always a positive value but can be 0.
 214          */
 215         public final int getParentCount() {
 216                 return parents.length;
 217         }
 218
 219         /**
 220          * Get the nth parent from this commit's parent list.
 221          *
 222          * @param nth
 223          *            parent index to obtain. Must be in the range 0 through
 224          *            {@link #getParentCount()}-1.
 225          * @return the specified parent.
 226          * @throws ArrayIndexOutOfBoundsException
 227          *             an invalid parent index was specified.
 228          */
 229         public final RevCommit getParent(final int nth) {
 230                 return parents[nth];
 231         }
 232
 233         /**
 234          * Obtain an array of all parents (<b>NOTE - THIS IS NOT A COPY</b>).
 235          * <p>
 236          * This method is exposed only to provide very fast, efficient access to
 237          * this commit's parent list. Applications relying on this list should be
 238          * very careful to ensure they do not modify its contents during their use
 239          * of it.
 240          *
 241          * @return the array of parents.
 242          */
 243         public final RevCommit[] getParents() {
 244                 return parents;
 245         }
 246
 247         /**
 248          * Obtain the raw unparsed commit body (<b>NOTE - THIS IS NOT A COPY</b>).
 249          * <p>
 250          * This method is exposed only to provide very fast, efficient access to
 251          * this commit's message buffer within a RevFilter. Applications relying on
 252          * this buffer should be very careful to ensure they do not modify its
 253          * contents during their use of it.
 254          *
 255          * @return the raw unparsed commit body. This is <b>NOT A COPY</b>.
 256          *         Altering the contents of this buffer may alter the walker's
 257          *         knowledge of this commit, and the results it produces.
 258          */
 259         public final byte[] getRawBuffer() {
 260                 return buffer;
 261         }
 262
 263         /**
 264          * Parse the author identity from the raw buffer.
 265          * <p>
 266          * This method parses and returns the content of the author line, after
 267          * taking the commit's character set into account and decoding the author
 268          * name and email address. This method is fairly expensive and produces a
 269          * new PersonIdent instance on each invocation. Callers should invoke this
 270          * method only if they are certain they will be outputting the result, and
 271          * should cache the return value for as long as necessary to use all
 272          * information from it.
 273          * <p>
 274          * RevFilter implementations should try to use {@link RawParseUtils} to scan
 275          * the {@link #getRawBuffer()} instead, as this will allow faster evaluation
 276          * of commits.
 277          *
 278          * @return identity of the author (name, email) and the time the commit was
 279          *         made by the author; null if no author line was found.
 280          */
 281         public final PersonIdent getAuthorIdent() {
 282                 final byte[] raw = buffer;
 283                 final int nameB = RawParseUtils.author(raw, 0);
 284                 if (nameB < 0)
 285                         return null;
 286                 return RawParseUtils.parsePersonIdent(raw, nameB);
 287         }
 288
 289         /**
 290          * Parse the committer identity from the raw buffer.
 291          * <p>
 292          * This method parses and returns the content of the committer line, after
 293          * taking the commit's character set into account and decoding the committer
 294          * name and email address. This method is fairly expensive and produces a
 295          * new PersonIdent instance on each invocation. Callers should invoke this
 296          * method only if they are certain they will be outputting the result, and
 297          * should cache the return value for as long as necessary to use all
 298          * information from it.
 299          * <p>
 300          * RevFilter implementations should try to use {@link RawParseUtils} to scan
 301          * the {@link #getRawBuffer()} instead, as this will allow faster evaluation
 302          * of commits.
 303          *
 304          * @return identity of the committer (name, email) and the time the commit
 305          *         was made by the comitter; null if no committer line was found.
 306          */
 307         public final PersonIdent getCommitterIdent() {
 308                 final byte[] raw = buffer;
 309                 final int nameB = RawParseUtils.committer(raw, 0);
 310                 if (nameB < 0)
 311                         return null;
 312                 return RawParseUtils.parsePersonIdent(raw, nameB);
 313         }
 314
 315         /**
 316          * Parse the complete commit message and decode it to a string.
 317          * <p>
 318          * This method parses and returns the message portion of the commit buffer,
 319          * after taking the commit's character set into account and decoding the
 320          * buffer using that character set. This method is a fairly expensive
 321          * operation and produces a new string on each invocation.
 322          *
 323          * @return decoded commit message as a string. Never null.
 324          */
 325         public final String getFullMessage() {
 326                 final byte[] raw = buffer;
 327                 final int msgB = RawParseUtils.commitMessage(raw, 0);
 328                 if (msgB < 0)
 329                         return "";
 330                 final Charset enc = RawParseUtils.parseEncoding(raw);
 331                 return RawParseUtils.decode(enc, raw, msgB, raw.length);
 332         }
 333
 334         /**
 335          * Parse the commit message and return the first "line" of it.
 336          * <p>
 337          * The first line is everything up to the first pair of LFs. This is the
 338          * "oneline" format, suitable for output in a single line display.
 339          * <p>
 340          * This method parses and returns the message portion of the commit buffer,
 341          * after taking the commit's character set into account and decoding the
 342          * buffer using that character set. This method is a fairly expensive
 343          * operation and produces a new string on each invocation.
 344          *
 345          * @return decoded commit message as a string. Never null. The returned
 346          *         string does not contain any LFs, even if the first paragraph
 347          *         spanned multiple lines. Embedded LFs are converted to spaces.
 348          */
 349         public final String getShortMessage() {
 350                 final byte[] raw = buffer;
 351                 final int msgB = RawParseUtils.commitMessage(raw, 0);
 352                 if (msgB < 0)
 353                         return "";
 354
 355                 final Charset enc = RawParseUtils.parseEncoding(raw);
 356                 final int msgE = RawParseUtils.endOfParagraph(raw, msgB);
 357                 String str = RawParseUtils.decode(enc, raw, msgB, msgE);
 358                 if (hasLF(raw, msgB, msgE))
 359                         str = str.replace('\n', ' ');
 360                 return str;
 361         }
 362
 363         private static boolean hasLF(final byte[] r, int b, final int e) {
 364                 while (b < e)
 365                         if (r[b++] == '\n')
 366                                 return true;
 367                 return false;
 368         }
 369
 370         /**
 371          * Reset this commit to allow another RevWalk with the same instances.
 372          * <p>
 373          * Subclasses <b>must</b> call <code>super.reset()</code> to ensure the
 374          * basic information can be correctly cleared out.
 375          */
 376         public void reset() {
 377                 inDegree = 0;
 378         }
 379
 380         public void dispose() {
 381                 flags &= ~PARSED;
 382                 buffer = null;
 383         }
 384 }