org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/RevWalkTextBuiltin.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.pgm;
  39
  40 import java.util.ArrayList;
  41 import java.util.EnumSet;
  42 import java.util.List;
  43
  44 import org.kohsuke.args4j.Argument;
  45 import org.kohsuke.args4j.Option;
  46 import org.spearce.jgit.lib.Constants;
  47 import org.spearce.jgit.lib.ObjectId;
  48 import org.spearce.jgit.pgm.opt.PathTreeFilterHandler;
  49 import org.spearce.jgit.revwalk.ObjectWalk;
  50 import org.spearce.jgit.revwalk.RevCommit;
  51 import org.spearce.jgit.revwalk.RevFlag;
  52 import org.spearce.jgit.revwalk.RevObject;
  53 import org.spearce.jgit.revwalk.RevSort;
  54 import org.spearce.jgit.revwalk.RevWalk;
  55 import org.spearce.jgit.revwalk.filter.AndRevFilter;
  56 import org.spearce.jgit.revwalk.filter.AuthorRevFilter;
  57 import org.spearce.jgit.revwalk.filter.CommitterRevFilter;
  58 import org.spearce.jgit.revwalk.filter.MessageRevFilter;
  59 import org.spearce.jgit.revwalk.filter.RevFilter;
  60 import org.spearce.jgit.treewalk.filter.AndTreeFilter;
  61 import org.spearce.jgit.treewalk.filter.TreeFilter;
  62
  63 abstract class RevWalkTextBuiltin extends TextBuiltin {
  64         RevWalk walk;
  65
  66         @Option(name = "--objects")
  67         boolean objects = false;
  68
  69         @Option(name = "--parents")
  70         boolean parents = false;
  71
  72         @Option(name = "--total-count")
  73         boolean count = false;
  74
  75         char[] outbuffer = new char[Constants.OBJECT_ID_LENGTH * 2];
  76
  77         private final EnumSet<RevSort> sorting = EnumSet.noneOf(RevSort.class);
  78
  79         private void enableRevSort(final RevSort type, final boolean on) {
  80                 if (on)
  81                         sorting.add(type);
  82                 else
  83                         sorting.remove(type);
  84         }
  85
  86         @Option(name = "--date-order")
  87         void enableDateOrder(final boolean on) {
  88                 enableRevSort(RevSort.COMMIT_TIME_DESC, on);
  89         }
  90
  91         @Option(name = "--topo-order")
  92         void enableTopoOrder(final boolean on) {
  93                 enableRevSort(RevSort.TOPO, on);
  94         }
  95
  96         @Option(name = "--reverse")
  97         void enableReverse(final boolean on) {
  98                 enableRevSort(RevSort.REVERSE, on);
  99         }
 100
 101         @Option(name = "--boundary")
 102         void enableBoundary(final boolean on) {
 103                 enableRevSort(RevSort.BOUNDARY, on);
 104         }
 105
 106         @Argument(index = 0, metaVar = "commit-ish")
 107         private final List<RevCommit> commits = new ArrayList<RevCommit>();
 108
 109         @Option(name = "--", metaVar = "path", multiValued = true, handler = PathTreeFilterHandler.class)
 110         private TreeFilter pathFilter = TreeFilter.ALL;
 111
 112         private final List<RevFilter> revLimiter = new ArrayList<RevFilter>();
 113
 114         @Option(name = "--author")
 115         void addAuthorRevFilter(final String who) {
 116                 revLimiter.add(AuthorRevFilter.create(who));
 117         }
 118
 119         @Option(name = "--committer")
 120         void addCommitterRevFilter(final String who) {
 121                 revLimiter.add(CommitterRevFilter.create(who));
 122         }
 123
 124         @Option(name = "--grep")
 125         void addCMessageRevFilter(final String msg) {
 126                 revLimiter.add(MessageRevFilter.create(msg));
 127         }
 128
 129         @Override
 130         protected void run() throws Exception {
 131                 walk = createWalk();
 132                 for (final RevSort s : sorting)
 133                         walk.sort(s, true);
 134
 135                 if (pathFilter != TreeFilter.ALL)
 136                         walk.setTreeFilter(AndTreeFilter.create(pathFilter,
 137                                         TreeFilter.ANY_DIFF));
 138
 139                 if (revLimiter.size() == 1)
 140                         walk.setRevFilter(revLimiter.get(0));
 141                 else if (revLimiter.size() > 1)
 142                         walk.setRevFilter(AndRevFilter.create(revLimiter));
 143
 144                 if (commits.isEmpty()) {
 145                         final ObjectId head = db.resolve(Constants.HEAD);
 146                         if (head == null)
 147                                 throw die("Cannot resolve " + Constants.HEAD);
 148                         commits.add(walk.parseCommit(head));
 149                 }
 150                 for (final RevCommit c : commits) {
 151                         final RevCommit real = argWalk == walk ? c : walk.parseCommit(c);
 152                         if (c.has(RevFlag.UNINTERESTING))
 153                                 walk.markUninteresting(real);
 154                         else
 155                                 walk.markStart(real);
 156                 }
 157
 158                 final long start = System.currentTimeMillis();
 159                 final int n = walkLoop();
 160                 if (count) {
 161                         final long end = System.currentTimeMillis();
 162                         System.err.print(n);
 163                         System.err.print(' ');
 164                         System.err.print(end - start);
 165                         System.err.print(" ms");
 166                         System.err.println();
 167                 }
 168         }
 169
 170         protected RevWalk createWalk() {
 171                 if (objects)
 172                         return new ObjectWalk(db);
 173                 if (argWalk == null)
 174                         argWalk = new RevWalk(db);
 175                 return argWalk;
 176         }
 177
 178         protected int walkLoop() throws Exception {
 179                 int n = 0;
 180                 for (final RevCommit c : walk) {
 181                         n++;
 182                         show(c);
 183                 }
 184                 if (walk instanceof ObjectWalk) {
 185                         final ObjectWalk ow = (ObjectWalk) walk;
 186                         for (;;) {
 187                                 final RevObject obj = ow.nextObject();
 188                                 if (obj == null)
 189                                         break;
 190                                 show(ow, obj);
 191                         }
 192                 }
 193                 return n;
 194         }
 195
 196         protected abstract void show(final RevCommit c) throws Exception;
 197
 198         protected void show(final ObjectWalk objectWalk,
 199                         final RevObject currentObject) throws Exception {
 200                 // Do nothing by default. Most applications cannot show an object.
 201         }
 202 }