github
/
jgit
mirror of https://gitee.com/github-mirror-repo/jgit.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Make Commit class only for writing 

The Commit class now only supports the creation of a commit object.
To read a commit, applictions should use RevCommit.  This permits
us to have exactly one implementation, and RevCommit's is faster
and more bug-free.

Change-Id: Ib573f7e15f36855112815269385c21dea532e2cf
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
stable-0.9
Shawn O. Pearce 14 years ago
parent
cf9537c8ce
commit
b46b635c03
15 changed files with 378 additions and 454 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      org.eclipse.jgit.junit/src/org/eclipse/jgit/junit/TestRepository.java
  2. 28
      org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/Clone.java
  3. 17
      org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/RebuildCommitGraph.java
  4. 4
      org.eclipse.jgit.test/tst/org/eclipse/jgit/api/MergeCommandTest.java
  5. 4
      org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ReflogConfigTest.java
  6. 2
      org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/CherryPickTest.java
  7. 2
      org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/SimpleMergeTest.java
  8. 159
      org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/T0003_Basic.java
  9. 4
      org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
  10. 8
      org.eclipse.jgit/src/org/eclipse/jgit/api/MergeCommand.java
  11. 104
      org.eclipse.jgit/src/org/eclipse/jgit/lib/BlobBasedConfig.java
  12. 379
      org.eclipse.jgit/src/org/eclipse/jgit/lib/Commit.java
  13. 18
      org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectInserter.java
  14. 78
      org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java
  15. 13
      org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevCommit.java

6
org.eclipse.jgit.junit/src/org/eclipse/jgit/junit/TestRepository.java
Unescape View File

@ -359,7 +359,7 @@ public class TestRepository<R extends Repository> {
final RevCommit... parents) throws Exception {
tick(secDelta);
final Commit c = new Commit(db);
final Commit c = new Commit();
c.setTreeId(tree);
c.setParentIds(parents);
c.setAuthor(new PersonIdent(author, new Date(now)));
@ -811,8 +811,8 @@ public class TestRepository<R extends Repository> {
if (self == null) {
TestRepository.this.tick(tick);
final Commit c = new Commit(db);
c.setParentIds(parents.toArray(new RevCommit[parents.size()]));
final Commit c = new Commit();
c.setParentIds(parents);
c.setAuthor(new PersonIdent(author, new Date(now)));
c.setCommitter(new PersonIdent(committer, new Date(now)));
c.setMessage(message);

28
org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/Clone.java
Unescape View File

@ -51,11 +51,10 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.Option;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.NotSupportedException;
import org.eclipse.jgit.errors.TransportException;
import org.eclipse.jgit.lib.Commit;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.GitIndex;
import org.eclipse.jgit.lib.Ref;
@ -64,12 +63,16 @@ import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.TextProgressMonitor;
import org.eclipse.jgit.lib.Tree;
import org.eclipse.jgit.lib.WorkDirCheckout;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.storage.file.FileRepository;
import org.eclipse.jgit.transport.FetchResult;
import org.eclipse.jgit.transport.RefSpec;
import org.eclipse.jgit.transport.RemoteConfig;
import org.eclipse.jgit.transport.Transport;
import org.eclipse.jgit.transport.URIish;
import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.Option;
@Command(common = true, usage = "usage_cloneRepositoryIntoNewDir")
class Clone extends AbstractFetchCommand {
@ -174,17 +177,30 @@ class Clone extends AbstractFetchCommand {
u.link(branch.getName());
}
final Commit commit = db.mapCommit(branch.getObjectId());
final RevCommit commit = parseCommit(branch);
final RefUpdate u = db.updateRef(Constants.HEAD);
u.setNewObjectId(commit.getCommitId());
u.setNewObjectId(commit);
u.forceUpdate();
final GitIndex index = new GitIndex(db);
final Tree tree = commit.getTree();
final Tree tree = db.mapTree(commit.getTree());
final WorkDirCheckout co;
co = new WorkDirCheckout(db, db.getWorkTree(), index, tree);
co.checkout();
index.write();
}
private RevCommit parseCommit(final Ref branch)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
final RevWalk rw = new RevWalk(db);
final RevCommit commit;
try {
commit = rw.parseCommit(branch.getObjectId());
} finally {
rw.release();
}
return commit;
}
}

17
org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/RebuildCommitGraph.java
Unescape View File

@ -56,26 +56,25 @@ import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.Option;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.ObjectWritingException;
import org.eclipse.jgit.lib.Commit;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectIdRef;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.ProgressMonitor;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.RefWriter;
import org.eclipse.jgit.lib.TextProgressMonitor;
import org.eclipse.jgit.lib.Tree;
import org.eclipse.jgit.pgm.CLIText;
import org.eclipse.jgit.pgm.TextBuiltin;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.storage.file.LockFile;
import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.Option;
/**
* Recreates a repository from another one's commit graph.
@ -164,8 +163,8 @@ class RebuildCommitGraph extends TextBuiltin {
}
pm.beginTask("Rewriting commits", queue.size());
final ObjectWriter ow = new ObjectWriter(db);
final ObjectId emptyTree = ow.writeTree(new Tree(db));
final ObjectInserter oi = db.newObjectInserter();
final ObjectId emptyTree = oi.insert(Constants.OBJ_TREE, new byte[] {});
final PersonIdent me = new PersonIdent("jgit rebuild-commitgraph",
"rebuild-commitgraph@localhost");
while (!queue.isEmpty()) {
@ -192,17 +191,19 @@ class RebuildCommitGraph extends TextBuiltin {
}
}
final Commit newc = new Commit(db);
final Commit newc = new Commit();
newc.setTreeId(emptyTree);
newc.setAuthor(new PersonIdent(me, new Date(t.commitTime)));
newc.setCommitter(newc.getAuthor());
newc.setParentIds(newParents);
newc.setMessage("ORIGINAL " + t.oldId.name() + "\n");
t.newId = ow.writeCommit(newc);
t.newId = oi.insert(Constants.OBJ_COMMIT,oi.format(newc));
rewrites.put(t.oldId, t.newId);
pm.update(1);
}
}
oi.flush();
oi.release();
pm.endTask();
}

4
org.eclipse.jgit.test/tst/org/eclipse/jgit/api/MergeCommandTest.java
Unescape View File

@ -155,8 +155,8 @@ public class MergeCommandTest extends RepositoryTestCase {
File workDir = db.getWorkTree();
if (workDir != null) {
WorkDirCheckout workDirCheckout = new WorkDirCheckout(db,
workDir, db.mapCommit(Constants.HEAD).getTree(),
db.getIndex(), db.mapCommit(branchName).getTree());
workDir, db.mapTree(Constants.HEAD),
db.getIndex(), db.mapTree(branchName));
workDirCheckout.setFailOnConflict(true);
try {
workDirCheckout.checkout();

4
org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ReflogConfigTest.java
Unescape View File

@ -104,11 +104,11 @@ public class ReflogConfigTest extends RepositoryTestCase {
private void commit(final Tree t, String commitMsg, PersonIdent author,
PersonIdent committer) throws IOException {
final Commit commit = new Commit(db);
final Commit commit = new Commit();
commit.setAuthor(author);
commit.setCommitter(committer);
commit.setMessage(commitMsg);
commit.setTree(t);
commit.setTreeId(t.getTreeId());
ObjectWriter writer = new ObjectWriter(db);
commit.setCommitId(writer.writeCommit(commit));

2
org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/CherryPickTest.java
Unescape View File

@ -131,7 +131,7 @@ public class CherryPickTest extends RepositoryTestCase {
private ObjectId commit(final ObjectInserter odi, final DirCache treeB,
final ObjectId[] parentIds) throws Exception {
final Commit c = new Commit(db);
final Commit c = new Commit();
c.setTreeId(treeB.writeTree(odi));
c.setAuthor(new PersonIdent("A U Thor", "a.u.thor", 1L, 0));
c.setCommitter(c.getAuthor());

2
org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/SimpleMergeTest.java
Unescape View File

@ -367,7 +367,7 @@ public class SimpleMergeTest extends SampleDataRepositoryTestCase {
private ObjectId commit(final ObjectInserter odi, final DirCache treeB,
final ObjectId[] parentIds) throws Exception {
final Commit c = new Commit(db);
final Commit c = new Commit();
c.setTreeId(treeB.writeTree(odi));
c.setAuthor(new PersonIdent("A U Thor", "a.u.thor", 1L, 0));
c.setCommitter(c.getAuthor());

159
org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/T0003_Basic.java
Unescape View File

@ -53,15 +53,20 @@ import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import org.eclipse.jgit.JGitText;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.Commit;
import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileTreeEntry;
import org.eclipse.jgit.lib.ObjectDatabase;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.RefUpdate;
@ -71,6 +76,8 @@ import org.eclipse.jgit.lib.Tag;
import org.eclipse.jgit.lib.Tree;
import org.eclipse.jgit.lib.TreeEntry;
import org.eclipse.jgit.lib.WriteTree;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
public class T0003_Basic extends SampleDataRepositoryTestCase {
public void test001_Initalize() {
@ -243,7 +250,8 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
assertEqualsPath(theDir.getParentFile(), r.getWorkTree());
assertEqualsPath(indexFile, r.getIndexFile());
assertEqualsPath(objDir, r.getObjectDatabase().getDirectory());
assertNotNull(r.mapCommit("6db9c2ebf75590eef973081736730a9ea169a0c4"));
assertNotNull(r.open(ObjectId
.fromString("6db9c2ebf75590eef973081736730a9ea169a0c4")));
// Must close or the default repo pack files created by this test gets
// locked via the alternate object directories on Windows.
r.close();
@ -374,13 +382,15 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
assertEquals(ObjectId.fromString("00b1f73724f493096d1ffa0b0f1f1482dbb8c936"),
t.getTreeId());
final Commit c = new Commit(db);
final Commit c = new Commit();
c.setAuthor(new PersonIdent(author, 1154236443000L, -4 * 60));
c.setCommitter(new PersonIdent(committer, 1154236443000L, -4 * 60));
c.setMessage("A Commit\n");
c.setTree(t);
c.setTreeId(t.getTreeId());
assertEquals(t.getTreeId(), c.getTreeId());
c.commit();
insertCommit(c);
final ObjectId cmtid = ObjectId.fromString(
"803aec4aba175e8ab1d666873c984c0308179099");
assertEquals(cmtid, c.getCommitId());
@ -399,12 +409,12 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
}
// Verify we can read it.
final Commit c2 = db.mapCommit(cmtid);
RevCommit c2 = parseCommit(c.getCommitId());
assertNotNull(c2);
assertEquals(c.getMessage(), c2.getMessage());
assertEquals(c.getTreeId(), c2.getTreeId());
assertEquals(c.getAuthor(), c2.getAuthor());
assertEquals(c.getCommitter(), c2.getCommitter());
assertEquals(c.getMessage(), c2.getFullMessage());
assertEquals(c.getTreeId(), c2.getTree());
assertEquals(c.getAuthor(), c2.getAuthorIdent());
assertEquals(c.getCommitter(), c2.getCommitterIdent());
}
public void test012_SubtreeExternalSorting() throws IOException {
@ -484,12 +494,12 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
final Tree almostEmptyTree = new Tree(db);
almostEmptyTree.addEntry(new FileTreeEntry(almostEmptyTree, emptyId, "empty".getBytes(), false));
final ObjectId almostEmptyTreeId = new ObjectWriter(db).writeTree(almostEmptyTree);
final Commit almostEmptyCommit = new Commit(db);
final Commit almostEmptyCommit = new Commit();
almostEmptyCommit.setAuthor(new PersonIdent(author, 1154236443000L, -2 * 60)); // not exactly the same
almostEmptyCommit.setCommitter(new PersonIdent(author, 1154236443000L, -2 * 60));
almostEmptyCommit.setMessage("test022\n");
almostEmptyCommit.setTreeId(almostEmptyTreeId);
ObjectId almostEmptyCommitId = new ObjectWriter(db).writeCommit(almostEmptyCommit);
ObjectId almostEmptyCommitId = insertCommit(almostEmptyCommit);
final Tag t = new Tag(db);
t.setObjId(almostEmptyCommitId);
t.setType("commit");
@ -511,17 +521,17 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
final Tree almostEmptyTree = new Tree(db);
almostEmptyTree.addEntry(new FileTreeEntry(almostEmptyTree, emptyId, "empty".getBytes(), false));
final ObjectId almostEmptyTreeId = new ObjectWriter(db).writeTree(almostEmptyTree);
Commit commit = new Commit(db);
Commit commit = new Commit();
commit.setTreeId(almostEmptyTreeId);
commit.setAuthor(new PersonIdent("Joe H\u00e4cker","joe@example.com",4294967295000L,60));
commit.setCommitter(new PersonIdent("Joe Hacker","joe2@example.com",4294967295000L,60));
commit.setEncoding("UTF-8");
commit.setMessage("\u00dcbergeeks");
ObjectId cid = new ObjectWriter(db).writeCommit(commit);
ObjectId cid = insertCommit(commit);
assertEquals("4680908112778718f37e686cbebcc912730b3154", cid.name());
Commit loadedCommit = db.mapCommit(cid);
assertNotSame(loadedCommit, commit);
assertEquals(commit.getMessage(), loadedCommit.getMessage());
RevCommit loadedCommit = parseCommit(cid);
assertEquals(commit.getMessage(), loadedCommit.getFullMessage());
}
public void test024_createCommitNonAscii() throws IOException {
@ -529,13 +539,13 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
final Tree almostEmptyTree = new Tree(db);
almostEmptyTree.addEntry(new FileTreeEntry(almostEmptyTree, emptyId, "empty".getBytes(), false));
final ObjectId almostEmptyTreeId = new ObjectWriter(db).writeTree(almostEmptyTree);
Commit commit = new Commit(db);
Commit commit = new Commit();
commit.setTreeId(almostEmptyTreeId);
commit.setAuthor(new PersonIdent("Joe H\u00e4cker","joe@example.com",4294967295000L,60));
commit.setCommitter(new PersonIdent("Joe Hacker","joe2@example.com",4294967295000L,60));
commit.setEncoding("ISO-8859-1");
commit.setMessage("\u00dcbergeeks");
ObjectId cid = new ObjectWriter(db).writeCommit(commit);
ObjectId cid = insertCommit(commit);
assertEquals("2979b39d385014b33287054b87f77bcb3ecb5ebf", cid.name());
}
@ -601,82 +611,82 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
assertEquals(ObjectId.fromString("00b1f73724f493096d1ffa0b0f1f1482dbb8c936"),
t.getTreeId());
final Commit c1 = new Commit(db);
final Commit c1 = new Commit();
c1.setAuthor(new PersonIdent(author, 1154236443000L, -4 * 60));
c1.setCommitter(new PersonIdent(committer, 1154236443000L, -4 * 60));
c1.setMessage("A Commit\n");
c1.setTree(t);
c1.setTreeId(t.getTreeId());
assertEquals(t.getTreeId(), c1.getTreeId());
c1.commit();
insertCommit(c1);
final ObjectId cmtid1 = ObjectId.fromString(
"803aec4aba175e8ab1d666873c984c0308179099");
assertEquals(cmtid1, c1.getCommitId());
final Commit c2 = new Commit(db);
final Commit c2 = new Commit();
c2.setAuthor(new PersonIdent(author, 1154236443000L, -4 * 60));
c2.setCommitter(new PersonIdent(committer, 1154236443000L, -4 * 60));
c2.setMessage("A Commit 2\n");
c2.setTree(t);
c2.setTreeId(t.getTreeId());
assertEquals(t.getTreeId(), c2.getTreeId());
c2.setParentIds(new ObjectId[] { c1.getCommitId() } );
c2.commit();
c2.setParentIds(c1.getCommitId());
insertCommit(c2);
final ObjectId cmtid2 = ObjectId.fromString(
"95d068687c91c5c044fb8c77c5154d5247901553");
assertEquals(cmtid2, c2.getCommitId());
Commit rm2 = db.mapCommit(cmtid2);
RevCommit rm2 = parseCommit(cmtid2);
assertNotSame(c2, rm2); // assert the parsed objects is not from the cache
assertEquals(c2.getAuthor(), rm2.getAuthor());
assertEquals(c2.getCommitId(), rm2.getCommitId());
assertEquals(c2.getMessage(), rm2.getMessage());
assertEquals(c2.getTree().getTreeId(), rm2.getTree().getTreeId());
assertEquals(1, rm2.getParentIds().length);
assertEquals(c1.getCommitId(), rm2.getParentIds()[0]);
final Commit c3 = new Commit(db);
assertEquals(c2.getAuthor(), rm2.getAuthorIdent());
assertEquals(c2.getCommitId(), rm2.getId());
assertEquals(c2.getMessage(), rm2.getFullMessage());
assertEquals(c2.getTreeId(), rm2.getTree().getId());
assertEquals(1, rm2.getParentCount());
assertEquals(c1.getCommitId(), rm2.getParent(0));
final Commit c3 = new Commit();
c3.setAuthor(new PersonIdent(author, 1154236443000L, -4 * 60));
c3.setCommitter(new PersonIdent(committer, 1154236443000L, -4 * 60));
c3.setMessage("A Commit 3\n");
c3.setTree(t);
c3.setTreeId(t.getTreeId());
assertEquals(t.getTreeId(), c3.getTreeId());
c3.setParentIds(new ObjectId[] { c1.getCommitId(), c2.getCommitId() });
c3.commit();
c3.setParentIds(c1.getCommitId(), c2.getCommitId());
insertCommit(c3);
final ObjectId cmtid3 = ObjectId.fromString(
"ce6e1ce48fbeeb15a83f628dc8dc2debefa066f4");
assertEquals(cmtid3, c3.getCommitId());
Commit rm3 = db.mapCommit(cmtid3);
RevCommit rm3 = parseCommit(cmtid3);
assertNotSame(c3, rm3); // assert the parsed objects is not from the cache
assertEquals(c3.getAuthor(), rm3.getAuthor());
assertEquals(c3.getCommitId(), rm3.getCommitId());
assertEquals(c3.getMessage(), rm3.getMessage());
assertEquals(c3.getTree().getTreeId(), rm3.getTree().getTreeId());
assertEquals(2, rm3.getParentIds().length);
assertEquals(c1.getCommitId(), rm3.getParentIds()[0]);
assertEquals(c2.getCommitId(), rm3.getParentIds()[1]);
final Commit c4 = new Commit(db);
assertEquals(c3.getAuthor(), rm3.getAuthorIdent());
assertEquals(c3.getCommitId(), rm3.getId());
assertEquals(c3.getMessage(), rm3.getFullMessage());
assertEquals(c3.getTreeId(), rm3.getTree().getId());
assertEquals(2, rm3.getParentCount());
assertEquals(c1.getCommitId(), rm3.getParent(0));
assertEquals(c2.getCommitId(), rm3.getParent(1));
final Commit c4 = new Commit();
c4.setAuthor(new PersonIdent(author, 1154236443000L, -4 * 60));
c4.setCommitter(new PersonIdent(committer, 1154236443000L, -4 * 60));
c4.setMessage("A Commit 4\n");
c4.setTree(t);
c4.setTreeId(t.getTreeId());
assertEquals(t.getTreeId(), c3.getTreeId());
c4.setParentIds(new ObjectId[] { c1.getCommitId(), c2.getCommitId(), c3.getCommitId() });
c4.commit();
c4.setParentIds(c1.getCommitId(), c2.getCommitId(), c3.getCommitId());
insertCommit(c4);
final ObjectId cmtid4 = ObjectId.fromString(
"d1fca9fe3fef54e5212eb67902c8ed3e79736e27");
assertEquals(cmtid4, c4.getCommitId());
Commit rm4 = db.mapCommit(cmtid4);
RevCommit rm4 = parseCommit(cmtid4);
assertNotSame(c4, rm3); // assert the parsed objects is not from the cache
assertEquals(c4.getAuthor(), rm4.getAuthor());
assertEquals(c4.getCommitId(), rm4.getCommitId());
assertEquals(c4.getMessage(), rm4.getMessage());
assertEquals(c4.getTree().getTreeId(), rm4.getTree().getTreeId());
assertEquals(3, rm4.getParentIds().length);
assertEquals(c1.getCommitId(), rm4.getParentIds()[0]);
assertEquals(c2.getCommitId(), rm4.getParentIds()[1]);
assertEquals(c3.getCommitId(), rm4.getParentIds()[2]);
assertEquals(c4.getAuthor(), rm4.getAuthorIdent());
assertEquals(c4.getCommitId(), rm4.getId());
assertEquals(c4.getMessage(), rm4.getFullMessage());
assertEquals(c4.getTreeId(), rm4.getTree().getId());
assertEquals(3, rm4.getParentCount());
assertEquals(c1.getCommitId(), rm4.getParent(0));
assertEquals(c2.getCommitId(), rm4.getParent(1));
assertEquals(c3.getCommitId(), rm4.getParent(2));
}
public void test027_UnpackedRefHigherPriorityThanPacked() throws IOException {
@ -717,13 +727,6 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
assertEquals(newId2, db.resolve("refs/heads/foobar"));
}
public void test029_mapObject() throws IOException {
assertEquals(new byte[0].getClass(), db.mapObject(ObjectId.fromString("5b6e7c66c276e7610d4a73c70ec1a1f7c1003259"), null).getClass());
assertEquals(Commit.class, db.mapObject(ObjectId.fromString("540a36d136cf413e4b064c2b0e0a4db60f77feab"), null).getClass());
assertEquals(Tree.class, db.mapObject(ObjectId.fromString("aabf2ffaec9b497f0950352b3e582d73035c2035"), null).getClass());
assertEquals(Tag.class, db.mapObject(ObjectId.fromString("17768080a2318cd89bba4c8b87834401e2095703"), null).getClass());
}
public void test30_stripWorkDir() {
File relCwd = new File(".");
File absCwd = relCwd.getAbsoluteFile();
@ -750,6 +753,30 @@ public class T0003_Basic extends SampleDataRepositoryTestCase {
}
private ObjectId insertCommit(final Commit commit) throws IOException,
UnsupportedEncodingException {
ObjectInserter oi = db.newObjectInserter();
try {
ObjectId id = oi.insert(Constants.OBJ_COMMIT, oi.format(commit));
oi.flush();
commit.setCommitId(id);
return id;
} finally {
oi.release();
}
}
private RevCommit parseCommit(AnyObjectId id)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
RevWalk rw = new RevWalk(db);
try {
return rw.parseCommit(id);
} finally {
rw.release();
}
}
/**
* Kick the timestamp of a local file.
* <p>

4
org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
Unescape View File

@ -162,12 +162,12 @@ public class CommitCommand extends GitCommand<RevCommit> {
ObjectId indexTreeId = index.writeTree(odi);
// Create a Commit object, populate it and write it
Commit commit = new Commit(repo);
Commit commit = new Commit();
commit.setCommitter(committer);
commit.setAuthor(author);
commit.setMessage(message);
commit.setParentIds(parents.toArray(new ObjectId[] {}));
commit.setParentIds(parents);
commit.setTreeId(indexTreeId);
ObjectId commitId = odi.insert(Constants.OBJ_COMMIT, odi
.format(commit));

8
org.eclipse.jgit/src/org/eclipse/jgit/api/MergeCommand.java
Unescape View File

@ -57,11 +57,11 @@ import org.eclipse.jgit.lib.GitIndex;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectIdRef;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Ref.Storage;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.WorkDirCheckout;
import org.eclipse.jgit.lib.Ref.Storage;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.merge.MergeStrategy;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
@ -176,8 +176,8 @@ public class MergeCommand extends GitCommand<MergeResult> {
File workDir = repo.getWorkTree();
if (workDir != null) {
WorkDirCheckout workDirCheckout = new WorkDirCheckout(repo,
workDir, headCommit.asCommit(revWalk).getTree(), index,
newHeadCommit.asCommit(revWalk).getTree());
workDir, repo.mapTree(headCommit.getTree()), index,
repo.mapTree(newHeadCommit.getTree()));
workDirCheckout.setFailOnConflict(true);
try {
workDirCheckout.checkout();

104
org.eclipse.jgit/src/org/eclipse/jgit/lib/BlobBasedConfig.java
Unescape View File

@ -51,15 +51,24 @@ import java.text.MessageFormat;
import org.eclipse.jgit.JGitText;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.RawParseUtils;
/**
* The configuration file based on the blobs stored in the repository
* Configuration file based on the blobs stored in the repository.
*
* This implementation currently only provides reading support, and is primarily
* useful for supporting the {@code .gitmodules} file.
*/
public class BlobBasedConfig extends Config {
/**
* The constructor from a byte array
* Parse a configuration from a byte array.
*
* @param base
* the base configuration file
@ -75,11 +84,11 @@ public class BlobBasedConfig extends Config {
}
/**
* The constructor from object identifier
* Load a configuration file from a blob.
*
* @param base
* the base configuration file
* @param r
* @param db
* the repository
* @param objectId
* the object identifier
@ -88,22 +97,50 @@ public class BlobBasedConfig extends Config {
* @throws ConfigInvalidException
* the blob is not a valid configuration format.
*/
public BlobBasedConfig(Config base, final Repository r,
final ObjectId objectId) throws IOException, ConfigInvalidException {
super(base);
ObjectLoader loader = r.open(objectId, Constants.OBJ_BLOB);
fromText(RawParseUtils.decode(loader.getCachedBytes()));
public BlobBasedConfig(Config base, Repository db, AnyObjectId objectId)
throws IOException, ConfigInvalidException {
this(base, read(db, objectId));
}
private static byte[] read(Repository db, AnyObjectId blobId)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
ObjectReader or = db.newObjectReader();
try {
return read(or, blobId);
} finally {
or.release();
}
}
private static byte[] read(ObjectReader or, AnyObjectId blobId)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
ObjectLoader loader = or.open(blobId, Constants.OBJ_BLOB);
if (loader.isLarge()) {
ObjectStream in = loader.openStream();
try {
byte[] buf = new byte[(int) in.getSize()];
IO.readFully(in, buf, 0, buf.length);
return buf;
} finally {
in.close();
}
}
return loader.getCachedBytes();
}
/**
* The constructor from commit and path
* Load a configuration file from a blob stored in a specific commit.
*
* @param base
* the base configuration file
* @param commit
* the commit that contains the object
* @param db
* the repository containing the objects.
* @param treeish
* the tree (or commit) that contains the object
* @param path
* the path within the tree of the commit
* the path within the tree
* @throws FileNotFoundException
* the path does not exist in the commit's tree.
* @throws IOException
@ -111,16 +148,37 @@ public class BlobBasedConfig extends Config {
* @throws ConfigInvalidException
* the blob is not a valid configuration format.
*/
public BlobBasedConfig(Config base, final Commit commit, final String path)
throws FileNotFoundException, IOException, ConfigInvalidException {
super(base);
final ObjectId treeId = commit.getTreeId();
final Repository r = commit.getRepository();
final TreeWalk tree = TreeWalk.forPath(r, path, treeId);
public BlobBasedConfig(Config base, Repository db, AnyObjectId treeish,
String path) throws FileNotFoundException, IOException,
ConfigInvalidException {
this(base, read(db, treeish, path));
}
private static byte[] read(Repository db, AnyObjectId treeish, String path)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
ObjectReader or = db.newObjectReader();
try {
TreeWalk tree = TreeWalk.forPath(or, path, asTree(or, treeish));
if (tree == null)
throw new FileNotFoundException(MessageFormat.format(JGitText.get().entryNotFoundByPath, path));
final ObjectId blobId = tree.getObjectId(0);
ObjectLoader loader = r.open(blobId,Constants.OBJ_BLOB);
fromText(RawParseUtils.decode(loader.getCachedBytes()));
throw new FileNotFoundException(MessageFormat.format(JGitText
.get().entryNotFoundByPath, path));
return read(or, tree.getObjectId(0));
} finally {
or.release();
}
}
private static AnyObjectId asTree(ObjectReader or, AnyObjectId treeish)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
if (treeish instanceof RevTree)
return treeish;
if (treeish instanceof RevCommit
&& ((RevCommit) treeish).getTree() != null)
return ((RevCommit) treeish).getTree();
return new RevWalk(or).parseTree(treeish).getId();
}
}

379
org.eclipse.jgit/src/org/eclipse/jgit/lib/Commit.java
Unescape View File

@ -45,25 +45,19 @@
package org.eclipse.jgit.lib;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.text.MessageFormat;
import org.eclipse.jgit.JGitText;
import org.eclipse.jgit.errors.CorruptObjectException;
import org.eclipse.jgit.errors.MissingObjectException;
import java.util.List;
/**
* Instances of this class represent a Commit object. It represents a snapshot
* in a Git repository, who created it and when.
* Mutable builder to construct a commit recording the state of a project.
*
* Applications should use this object when they need to manually construct a
* commit and want precise control over its fields. For a higher level interface
* see {@link org.eclipse.jgit.api.CommitCommand}.
*/
public class Commit implements Treeish {
public class Commit {
private static final ObjectId[] EMPTY_OBJECTID_LIST = new ObjectId[0];
private final Repository objdb;
private ObjectId commitId;
private ObjectId treeId;
@ -76,102 +70,21 @@ public class Commit implements Treeish {
private String message;
private Tree treeObj;
private byte[] raw;
private Charset encoding;
/**
* Create an empty commit object. More information must be fed to this
* object to make it useful.
*
* @param db
* The repository with which to associate it.
*/
public Commit(final Repository db) {
objdb = db;
parentIds = EMPTY_OBJECTID_LIST;
}
/**
* Create a commit associated with these parents and associate it with a
* repository.
*
* @param db
* The repository to which this commit object belongs
* @param parentIds
* Id's of the parent(s)
*/
public Commit(final Repository db, final ObjectId[] parentIds) {
objdb = db;
this.parentIds = parentIds;
}
/**
* Create a commit object with the specified id and data from and existing
* commit object in a repository.
*
* @param db
* The repository to which this commit object belongs
* @param id
* Commit id
* @param raw
* Raw commit object data
*/
public Commit(final Repository db, final ObjectId id, final byte[] raw) {
objdb = db;
commitId = id;
treeId = ObjectId.fromString(raw, 5);
parentIds = new ObjectId[1];
int np=0;
int rawPtr = 46;
for (;;) {
if (raw[rawPtr] != 'p')
break;
if (np == 0) {
parentIds[np++] = ObjectId.fromString(raw, rawPtr + 7);
} else if (np == 1) {
parentIds = new ObjectId[] { parentIds[0], ObjectId.fromString(raw, rawPtr + 7) };
np++;
} else {
if (parentIds.length <= np) {
ObjectId[] old = parentIds;
parentIds = new ObjectId[parentIds.length+32];
for (int i=0; i<np; ++i)
parentIds[i] = old[i];
}
parentIds[np++] = ObjectId.fromString(raw, rawPtr + 7);
}
rawPtr += 48;
}
if (np != parentIds.length) {
ObjectId[] old = parentIds;
parentIds = new ObjectId[np];
for (int i=0; i<np; ++i)
parentIds[i] = old[i];
} else
if (np == 0)
/** Initialize an empty commit. */
public Commit() {
parentIds = EMPTY_OBJECTID_LIST;
this.raw = raw;
encoding = Constants.CHARSET;
}
/**
* @return get repository for the commit
*/
public Repository getRepository() {
return objdb;
}
/**
* @return The commit object id
*/
/** @return this commit's object id. */
public ObjectId getCommitId() {
return commitId;
}
/**
* Set the id of this object.
* Set the id of this commit object.
*
* @param id
* the id that we calculated for this object.
@ -180,6 +93,7 @@ public class Commit implements Treeish {
commitId = id;
}
/** @return id of the root tree listing this commit's snapshot. */
public ObjectId getTreeId() {
return treeId;
}
@ -188,198 +102,197 @@ public class Commit implements Treeish {
* Set the tree id for this commit object
*
* @param id
* the tree identity.
*/
public void setTreeId(final ObjectId id) {
if (treeId==null || !treeId.equals(id)) {
treeObj = null;
}
treeId = id;
}
public Tree getTree() throws IOException {
if (treeObj == null) {
treeObj = objdb.mapTree(getTreeId());
if (treeObj == null) {
throw new MissingObjectException(getTreeId(),
Constants.TYPE_TREE);
}
}
return treeObj;
}
/**
* Set the tree object for this commit
* @see #setTreeId
* @param t the Tree object
*/
public void setTree(final Tree t) {
treeId = t.getTreeId();
treeObj = t;
public void setTreeId(AnyObjectId id) {
treeId = id.copy();
commitId = null;
}
/**
* @return the author and authoring time for this commit
*/
/** @return the author of this commit (who wrote it). */
public PersonIdent getAuthor() {
decode();
return author;
}
/**
* Set the author and authoring time for this commit
* @param a
* Set the author (name, email address, and date) of who wrote the commit.
*
* @param newAuthor
* the new author. Should not be null.
*/
public void setAuthor(final PersonIdent a) {
author = a;
public void setAuthor(PersonIdent newAuthor) {
author = newAuthor;
commitId = null;
}
/**
* @return the committer and commit time for this object
*/
/** @return the committer and commit time for this object. */
public PersonIdent getCommitter() {
decode();
return committer;
}
/**
* Set the committer and commit time for this object
* @param c the committer information
*
* @param newCommitter
* the committer information. Should not be null.
*/
public void setCommitter(final PersonIdent c) {
committer = c;
public void setCommitter(PersonIdent newCommitter) {
committer = newCommitter;
commitId = null;
}
/**
* @return the object ids of this commit
*/
/** @return the ancestors of this commit. Never null. */
public ObjectId[] getParentIds() {
return parentIds;
}
/**
* @return the commit message
* Set the parent of this commit.
*
* @param newParent
* the single parent for the commit.
*/
public String getMessage() {
decode();
return message;
public void setParentId(AnyObjectId newParent) {
parentIds = new ObjectId[] { newParent.copy() };
commitId = null;
}
/**
* Set the parents of this commit
* @param parentIds
* Set the parents of this commit.
*
* @param parent1
* the first parent of this commit. Typically this is the current
* value of the {@code HEAD} reference and is thus the current
* branch's position in history.
* @param parent2
* the second parent of this merge commit. Usually this is the
* branch being merged into the current branch.
*/
public void setParentIds(ObjectId[] parentIds) {
this.parentIds = new ObjectId[parentIds.length];
for (int i=0; i<parentIds.length; ++i)
this.parentIds[i] = parentIds[i];
public void setParentIds(AnyObjectId parent1, AnyObjectId parent2) {
parentIds = new ObjectId[] { parent1.copy(), parent2.copy() };
commitId = null;
}
private void decode() {
// FIXME: handle I/O errors
if (raw != null) {
try {
DataInputStream br = new DataInputStream(new ByteArrayInputStream(raw));
String n = br.readLine();
if (n == null || !n.startsWith("tree ")) {
throw new CorruptObjectException(commitId, JGitText.get().corruptObjectNotree);
}
while ((n = br.readLine()) != null && n.startsWith("parent ")) {
// empty body
}
if (n == null || !n.startsWith("author ")) {
throw new CorruptObjectException(commitId, JGitText.get().corruptObjectNoAuthor);
}
String rawAuthor = n.substring("author ".length());
n = br.readLine();
if (n == null || !n.startsWith("committer ")) {
throw new CorruptObjectException(commitId, JGitText.get().corruptObjectNoCommitter);
}
String rawCommitter = n.substring("committer ".length());
n = br.readLine();
if (n != null && n.startsWith( "encoding"))
encoding = Charset.forName(n.substring("encoding ".length()));
else
if (n == null || !n.equals("")) {
throw new CorruptObjectException(commitId, MessageFormat.format(
JGitText.get().corruptObjectMalformedHeader, n));
}
byte[] readBuf = new byte[br.available()]; // in-memory stream so this is all bytes left
br.read(readBuf);
int msgstart = readBuf.length != 0 ? ( readBuf[0] == '\n' ? 1 : 0 ) : 0;
// If encoding is not specified, the default for commit is UTF-8
if (encoding == null) encoding = Constants.CHARSET;
// TODO: this isn't reliable so we need to guess the encoding from the actual content
author = new PersonIdent(new String(rawAuthor.getBytes(),encoding.name()));
committer = new PersonIdent(new String(rawCommitter.getBytes(),encoding.name()));
message = new String(readBuf,msgstart, readBuf.length-msgstart, encoding.name());
} catch (IOException e) {
e.printStackTrace();
} finally {
raw = null;
}
}
/**
* Set the parents of this commit.
*
* @param newParents
* the entire list of parents for this commit.
*/
public void setParentIds(ObjectId... newParents) {
parentIds = new ObjectId[newParents.length];
for (int i = 0; i < newParents.length; i++)
parentIds[i] = newParents[i].copy();
commitId = null;
}
/**
* Set the commit message
* Set the parents of this commit.
*
* @param m the commit message
* @param newParents
* the entire list of parents for this commit.
*/
public void setMessage(final String m) {
message = m;
public void setParentIds(List<? extends AnyObjectId> newParents) {
parentIds = new ObjectId[newParents.size()];
for (int i = 0; i < newParents.size(); i++)
parentIds[i] = newParents.get(i).copy();
commitId = null;
}
/**
* Persist this commit object
* Add a parent onto the end of the parent list.
*
* @throws IOException
* @param additionalParent
* new parent to add onto the end of the current parent list.
*/
public void commit() throws IOException {
if (getCommitId() != null)
throw new IllegalStateException(MessageFormat.format(JGitText.get().commitAlreadyExists, getCommitId()));
ObjectInserter odi = objdb.newObjectInserter();
try {
ObjectId id = odi.insert(Constants.OBJ_COMMIT, odi.format(this));
odi.flush();
setCommitId(id);
} finally {
odi.release();
public void addParentId(AnyObjectId additionalParent) {
if (parentIds.length == 0) {
setParentId(additionalParent);
} else {
ObjectId[] newParents = new ObjectId[parentIds.length + 1];
for (int i = 0; i < parentIds.length; i++)
newParents[i] = parentIds[i];
newParents[parentIds.length] = additionalParent.copy();
parentIds = newParents;
commitId = null;
}
}
public String toString() {
return "Commit[" + ObjectId.toString(getCommitId()) + " " + getAuthor() + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
/** @return the complete commit message. */
public String getMessage() {
return message;
}
/**
* State the encoding for the commit information
* Set the commit message.
*
* @param e
* the encoding. See {@link Charset}
* @param newMessage
* the commit message. Should not be null.
*/
public void setEncoding(String e) {
encoding = Charset.forName(e);
public void setMessage(final String newMessage) {
message = newMessage;
}
/**
* State the encoding for the commit information
* Set the encoding for the commit information
*
* @param e
* the encoding. See {@link Charset}
* @param encodingName
* the encoding name. See {@link Charset#forName(String)}.
*/
public void setEncoding(Charset e) {
encoding = e;
public void setEncoding(String encodingName) {
encoding = Charset.forName(encodingName);
}
/**
* @return the encoding used. See {@link Charset}
* Set the encoding for the commit information
*
* @param enc
* the encoding to use.
*/
public String getEncoding() {
if (encoding != null)
return encoding.name();
else
return null;
public void setEncoding(Charset enc) {
encoding = enc;
}
/** @return the encoding that should be used for the commit message text. */
public Charset getEncoding() {
return encoding;
}
@Override
public String toString() {
StringBuilder r = new StringBuilder();
r.append("Commit");
if (commitId != null)
r.append("[" + commitId.name() + "]");
r.append("={\n");
r.append("tree ");
r.append(treeId != null ? treeId.name() : "NOT_SET");
r.append("\n");
for (ObjectId p : parentIds) {
r.append("parent ");
r.append(p.name());
r.append("\n");
}
r.append("author ");
r.append(author != null ? author.toString() : "NOT_SET");
r.append("\n");
r.append("committer ");
r.append(committer != null ? committer.toString() : "NOT_SET");
r.append("\n");
if (encoding != null && encoding != Constants.CHARSET) {
r.append("encoding ");
r.append(encoding.name());
r.append("\n");
}
r.append("\n");
r.append(message != null ? message : "");
r.append("}");
return r.toString();
}
}

18
org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectInserter.java
Unescape View File

@ -53,6 +53,7 @@ import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.text.MessageFormat;
@ -304,10 +305,7 @@ public abstract class ObjectInserter {
*/
public final byte[] format(Commit commit)
throws UnsupportedEncodingException {
String encoding = commit.getEncoding();
if (encoding == null)
encoding = Constants.CHARACTER_ENCODING;
Charset encoding = commit.getEncoding();
ByteArrayOutputStream os = new ByteArrayOutputStream();
OutputStreamWriter w = new OutputStreamWriter(os, encoding);
try {
@ -316,11 +314,10 @@ public abstract class ObjectInserter {
commit.getTreeId().copyTo(os);
os.write('\n');
ObjectId[] ps = commit.getParentIds();
for (int i = 0; i < ps.length; ++i) {
for (ObjectId p : commit.getParentIds()) {
os.write(hparent);
os.write(' ');
ps[i].copyTo(os);
p.copyTo(os);
os.write('\n');
}
@ -336,16 +333,19 @@ public abstract class ObjectInserter {
w.flush();
os.write('\n');
if (!encoding.equals(Constants.CHARACTER_ENCODING)) {
if (encoding != Constants.CHARSET) {
os.write(hencoding);
os.write(' ');
os.write(Constants.encodeASCII(encoding));
os.write(Constants.encodeASCII(encoding.name()));
os.write('\n');
}
os.write('\n');
if (commit.getMessage() != null) {
w.write(commit.getMessage());
w.flush();
}
} catch (IOException err) {
// This should never occur, the only way to get it above is
// for the ByteArrayOutputStream to throw, but it doesn't.

78
org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java
Unescape View File

@ -270,84 +270,6 @@ public abstract class Repository {
return getObjectDatabase().open(objectId, typeHint);
}
/**
* Access a Commit object using a symbolic reference. This reference may
* be a SHA-1 or ref in combination with a number of symbols translating
* from one ref or SHA1-1 to another, such as HEAD^ etc.
*
* @param revstr a reference to a git commit object
* @return a Commit named by the specified string
* @throws IOException for I/O error or unexpected object type.
*
* @see #resolve(String)
* @deprecated Use {@link #resolve(String)} and pass its return value to
* {@link org.eclipse.jgit.revwalk.RevWalk#parseCommit(AnyObjectId)}.
*/
@Deprecated
public Commit mapCommit(final String revstr) throws IOException {
final ObjectId id = resolve(revstr);
return id != null ? mapCommit(id) : null;
}
/**
* Access any type of Git object by id and
*
* @param id
* SHA-1 of object to read
* @param refName optional, only relevant for simple tags
* @return The Git object if found or null
* @throws IOException
* @deprecated Use {@link org.eclipse.jgit.revwalk.RevWalk#parseCommit(AnyObjectId)},
* or {@link org.eclipse.jgit.revwalk.RevWalk#parseTag(AnyObjectId)}.
* To read a tree, use {@link org.eclipse.jgit.treewalk.TreeWalk#addTree(AnyObjectId)}.
* To read a blob, open it with {@link #open(AnyObjectId)}.
*/
@Deprecated
public Object mapObject(final ObjectId id, final String refName) throws IOException {
final ObjectLoader or;
try {
or = open(id);
} catch (MissingObjectException notFound) {
return null;
}
final byte[] raw = or.getCachedBytes();
switch (or.getType()) {
case Constants.OBJ_TREE:
return new Tree(this, id, raw);
case Constants.OBJ_COMMIT:
return new Commit(this, id, raw);
case Constants.OBJ_TAG:
return new Tag(this, id, refName, raw);
case Constants.OBJ_BLOB:
return raw;
default:
throw new IncorrectObjectTypeException(id,
JGitText.get().incorrectObjectType_COMMITnorTREEnorBLOBnorTAG);
}
}
/**
* Access a Commit by SHA'1 id.
* @param id
* @return Commit or null
* @throws IOException for I/O error or unexpected object type.
* @deprecated Use {@link org.eclipse.jgit.revwalk.RevWalk#parseCommit(AnyObjectId)}.
*/
@Deprecated
public Commit mapCommit(final ObjectId id) throws IOException {
final ObjectLoader or;
try {
or = open(id, Constants.OBJ_COMMIT);
} catch (MissingObjectException notFound) {
return null;
}
return new Commit(this, id, or.getCachedBytes());
}
/**
* Access a Tree object using a symbolic reference. This reference may
* be a SHA-1 or ref in combination with a number of symbols translating

13
org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevCommit.java
Unescape View File

@ -53,7 +53,6 @@ import java.util.List;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.Commit;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.MutableObjectId;
import org.eclipse.jgit.lib.PersonIdent;
@ -206,18 +205,6 @@ public class RevCommit extends RevObject {
return commitTime;
}
/**
* Parse this commit buffer for display.
*
* @param walk
* revision walker owning this reference.
* @return parsed commit.
*/
public final Commit asCommit(final RevWalk walk) {
// TODO(spearce) Remove repository when this method dies.
return new Commit(walk.repository, this, buffer);
}
/**
* Get a reference to this commit's tree.
*

Write Preview
Loading…
Cancel
Save