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         @Override
 140         public int getType() {
 141                 return Constants.OBJ_COMMIT;
 142         }
 143
 144         static void carryFlags(RevCommit c, final int carry) {
 145                 for (;;) {
 146                         final RevCommit[] pList = c.parents;
 147                         if (pList == null)
 148                                 return;
 149                         final int n = pList.length;
 150                         if (n == 0)
 151                                 return;
 152
 153                         for (int i = 1; i < n; i++) {
 154                                 final RevCommit p = pList[i];
 155                                 if ((p.flags & carry) == carry)
 156                                         continue;
 157                                 p.flags |= carry;
 158                                 carryFlags(p, carry);
 159                         }
 160
 161                         c = pList[0];
 162                         if ((c.flags & carry) == carry)
 163                                 return;
 164                         c.flags |= carry;
 165                 }
 166         }
 167
 168         /**
 169          * Carry a RevFlag set on this commit to its parents.
 170          * <p>
 171          * If this commit is parsed, has parents, and has the supplied flag set on
 172          * it we automatically add it to the parents, grand-parents, and so on until
 173          * an unparsed commit or a commit with no parents is discovered. This
 174          * permits applications to force a flag through the history chain when
 175          * necessary.
 176          *
 177          * @param flag
 178          *            the single flag value to carry back onto parents.
 179          */
 180         public void carry(final RevFlag flag) {
 181                 final int carry = flags & flag.mask;
 182                 if (carry != 0)
 183                         carryFlags(this, carry);
 184         }
 185
 186         /**
 187          * Time from the "committer " line of the buffer.
 188          *
 189          * @return time, expressed as seconds since the epoch.
 190          */
 191         public final int getCommitTime() {
 192                 return commitTime;
 193         }
 194
 195         /**
 196          * Parse this commit buffer for display.
 197          *
 198          * @param walk
 199          *            revision walker owning this reference.
 200          * @return parsed commit.
 201          */
 202         public final Commit asCommit(final RevWalk walk) {
 203                 return new Commit(walk.db, this, buffer);
 204         }
 205
 206         /**
 207          * Get a reference to this commit's tree.
 208          *
 209          * @return tree of this commit.
 210          */
 211         public final RevTree getTree() {
 212                 return tree;
 213         }
 214
 215         /**
 216          * Get the number of parent commits listed in this commit.
 217          *
 218          * @return number of parents; always a positive value but can be 0.
 219          */
 220         public final int getParentCount() {
 221                 return parents.length;
 222         }
 223
 224         /**
 225          * Get the nth parent from this commit's parent list.
 226          *
 227          * @param nth
 228          *            parent index to obtain. Must be in the range 0 through
 229          *            {@link #getParentCount()}-1.
 230          * @return the specified parent.
 231          * @throws ArrayIndexOutOfBoundsException
 232          *             an invalid parent index was specified.
 233          */
 234         public final RevCommit getParent(final int nth) {
 235                 return parents[nth];
 236         }
 237
 238         /**
 239          * Obtain an array of all parents (<b>NOTE - THIS IS NOT A COPY</b>).
 240          * <p>
 241          * This method is exposed only to provide very fast, efficient access to
 242          * this commit's parent list. Applications relying on this list should be
 243          * very careful to ensure they do not modify its contents during their use
 244          * of it.
 245          *
 246          * @return the array of parents.
 247          */
 248         public final RevCommit[] getParents() {
 249                 return parents;
 250         }
 251
 252         /**
 253          * Obtain the raw unparsed commit body (<b>NOTE - THIS IS NOT A COPY</b>).
 254          * <p>
 255          * This method is exposed only to provide very fast, efficient access to
 256          * this commit's message buffer within a RevFilter. Applications relying on
 257          * this buffer should be very careful to ensure they do not modify its
 258          * contents during their use of it.
 259          *
 260          * @return the raw unparsed commit body. This is <b>NOT A COPY</b>.
 261          *         Altering the contents of this buffer may alter the walker's
 262          *         knowledge of this commit, and the results it produces.
 263          */
 264         public final byte[] getRawBuffer() {
 265                 return buffer;
 266         }
 267
 268         /**
 269          * Parse the author identity from the raw buffer.
 270          * <p>
 271          * This method parses and returns the content of the author line, after
 272          * taking the commit's character set into account and decoding the author
 273          * name and email address. This method is fairly expensive and produces a
 274          * new PersonIdent instance on each invocation. Callers should invoke this
 275          * method only if they are certain they will be outputting the result, and
 276          * should cache the return value for as long as necessary to use all
 277          * information from it.
 278          * <p>
 279          * RevFilter implementations should try to use {@link RawParseUtils} to scan
 280          * the {@link #getRawBuffer()} instead, as this will allow faster evaluation
 281          * of commits.
 282          *
 283          * @return identity of the author (name, email) and the time the commit was
 284          *         made by the author; null if no author line was found.
 285          */
 286         public final PersonIdent getAuthorIdent() {
 287                 final byte[] raw = buffer;
 288                 final int nameB = RawParseUtils.author(raw, 0);
 289                 if (nameB < 0)
 290                         return null;
 291                 return RawParseUtils.parsePersonIdent(raw, nameB);
 292         }
 293
 294         /**
 295          * Parse the committer identity from the raw buffer.
 296          * <p>
 297          * This method parses and returns the content of the committer line, after
 298          * taking the commit's character set into account and decoding the committer
 299          * name and email address. This method is fairly expensive and produces a
 300          * new PersonIdent instance on each invocation. Callers should invoke this
 301          * method only if they are certain they will be outputting the result, and
 302          * should cache the return value for as long as necessary to use all
 303          * information from it.
 304          * <p>
 305          * RevFilter implementations should try to use {@link RawParseUtils} to scan
 306          * the {@link #getRawBuffer()} instead, as this will allow faster evaluation
 307          * of commits.
 308          *
 309          * @return identity of the committer (name, email) and the time the commit
 310          *         was made by the comitter; null if no committer line was found.
 311          */
 312         public final PersonIdent getCommitterIdent() {
 313                 final byte[] raw = buffer;
 314                 final int nameB = RawParseUtils.committer(raw, 0);
 315                 if (nameB < 0)
 316                         return null;
 317                 return RawParseUtils.parsePersonIdent(raw, nameB);
 318         }
 319
 320         /**
 321          * Parse the complete commit message and decode it to a string.
 322          * <p>
 323          * This method parses and returns the message portion of the commit buffer,
 324          * after taking the commit's character set into account and decoding the
 325          * buffer using that character set. This method is a fairly expensive
 326          * operation and produces a new string on each invocation.
 327          *
 328          * @return decoded commit message as a string. Never null.
 329          */
 330         public final String getFullMessage() {
 331                 final byte[] raw = buffer;
 332                 final int msgB = RawParseUtils.commitMessage(raw, 0);
 333                 if (msgB < 0)
 334                         return "";
 335                 final Charset enc = RawParseUtils.parseEncoding(raw);
 336                 return RawParseUtils.decode(enc, raw, msgB, raw.length);
 337         }
 338
 339         /**
 340          * Parse the commit message and return the first "line" of it.
 341          * <p>
 342          * The first line is everything up to the first pair of LFs. This is the
 343          * "oneline" format, suitable for output in a single line display.
 344          * <p>
 345          * This method parses and returns the message portion of the commit buffer,
 346          * after taking the commit's character set into account and decoding the
 347          * buffer using that character set. This method is a fairly expensive
 348          * operation and produces a new string on each invocation.
 349          *
 350          * @return decoded commit message as a string. Never null. The returned
 351          *         string does not contain any LFs, even if the first paragraph
 352          *         spanned multiple lines. Embedded LFs are converted to spaces.
 353          */
 354         public final String getShortMessage() {
 355                 final byte[] raw = buffer;
 356                 final int msgB = RawParseUtils.commitMessage(raw, 0);
 357                 if (msgB < 0)
 358                         return "";
 359
 360                 final Charset enc = RawParseUtils.parseEncoding(raw);
 361                 final int msgE = RawParseUtils.endOfParagraph(raw, msgB);
 362                 String str = RawParseUtils.decode(enc, raw, msgB, msgE);
 363                 if (hasLF(raw, msgB, msgE))
 364                         str = str.replace('\n', ' ');
 365                 return str;
 366         }
 367
 368         private static boolean hasLF(final byte[] r, int b, final int e) {
 369                 while (b < e)
 370                         if (r[b++] == '\n')
 371                                 return true;
 372                 return false;
 373         }
 374
 375         /**
 376          * Reset this commit to allow another RevWalk with the same instances.
 377          * <p>
 378          * Subclasses <b>must</b> call <code>super.reset()</code> to ensure the
 379          * basic information can be correctly cleared out.
 380          */
 381         public void reset() {
 382                 inDegree = 0;
 383         }
 384
 385         public void dispose() {
 386                 flags &= ~PARSED;
 387                 buffer = null;
 388         }
 389 }