Browse Source

Merge branch 'stable-1.3'

* stable-1.3:
  Prepare post 1.3.0.201202121842-rc4 builds
  JGit 1.3.0.201202121842-rc4
  Support gitdir references in working tree .git file
  Support committing submodule updates
  Update iplog tool's README

Change-Id: Id70f4d4b059b03d4fa6fbd9137b81a337e9c48e8
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
stable-2.0
Matthias Sohn 13 years ago
parent
commit
de48250da5
  1. 12
      org.eclipse.jgit.iplog/README
  2. 106
      org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
  3. 103
      org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleWalkTest.java
  4. 1
      org.eclipse.jgit/resources/org/eclipse/jgit/JGitText.properties
  5. 1
      org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java
  6. 9
      org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
  7. 50
      org.eclipse.jgit/src/org/eclipse/jgit/lib/BaseRepositoryBuilder.java
  8. 53
      org.eclipse.jgit/src/org/eclipse/jgit/submodule/SubmoduleWalk.java
  9. 2
      org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
  10. 14
      org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java

12
org.eclipse.jgit.iplog/README

@ -11,19 +11,19 @@
# $JGIT_BASE/.eclipse_iplog
# -----------------------------------------------------------
# Prepare:
# jgit work tree base dir
export JGIT_BASE="c:/data/ide/helios/jgit"
# jgit executable (assuming jgit mvn build is up to date)
export jgit="~/src/git/jgit/org.eclipse.jgit.pgm/target/jgit"
# repository work dir root path
export WORK_DIR="c:/data/ide/helios/jgit"
export WORK_DIR="~/src/git/jgit/"
# cd to repository work dir root path (for jgit this is identical to $JGIT_BASE)
# cd to repository work dir root path
cd $WORK_DIR
# -----------------------------------------------------------
# Update the CQ list:
# - this command updates file .eclipse_iplog
java -jar $JGIT_BASE/org.eclipse.jgit.pgm/target/jgit-cli.jar eclipse-ipzilla
jgit eclipse-ipzilla
# - if there are any updates 'git commit' them
git add .eclipse_iplog
@ -49,6 +49,6 @@ ssh -p 29418 username@egit.eclipse.org gerrit gsql --format PRETTY
# options:
# -- version : the project version the iplog is to be generated for
# - o : the output file
java -jar $JGIT_BASE/org.eclipse.jgit.pgm/target/jgit-cli.jar eclipse-iplog --version=0.8.0 -o jgit-0.8.0.xml
jgit eclipse-iplog --version=1.3.0 -o $WORK_DIR/jgit-1.3.0.xml

106
org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java

@ -44,15 +44,25 @@ package org.eclipse.jgit.api;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.util.List;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.lib.ConfigConstants;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryTestCase;
import org.eclipse.jgit.lib.StoredConfig;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.submodule.SubmoduleWalk;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.jgit.treewalk.filter.TreeFilter;
import org.eclipse.jgit.util.FS;
import org.junit.Test;
@ -152,4 +162,100 @@ public class CommitCommandTest extends RepositoryTestCase {
assertNotNull(walk);
assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
}
@Test
public void commitNewSubmodule() throws Exception {
Git git = new Git(db);
writeTrashFile("file.txt", "content");
git.add().addFilepattern("file.txt").call();
RevCommit commit = git.commit().setMessage("create file").call();
SubmoduleAddCommand command = new SubmoduleAddCommand(db);
String path = "sub";
command.setPath(path);
String uri = db.getDirectory().toURI().toString();
command.setURI(uri);
Repository repo = command.call();
assertNotNull(repo);
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
assertNotNull(generator.getRepository());
assertEquals(commit, repo.resolve(Constants.HEAD));
RevCommit submoduleCommit = git.commit().setMessage("submodule add")
.setOnly(path).call();
assertNotNull(submoduleCommit);
TreeWalk walk = new TreeWalk(db);
walk.addTree(commit.getTree());
walk.addTree(submoduleCommit.getTree());
walk.setFilter(TreeFilter.ANY_DIFF);
List<DiffEntry> diffs = DiffEntry.scan(walk);
assertEquals(1, diffs.size());
DiffEntry subDiff = diffs.get(0);
assertEquals(FileMode.MISSING, subDiff.getOldMode());
assertEquals(FileMode.GITLINK, subDiff.getNewMode());
assertEquals(ObjectId.zeroId(), subDiff.getOldId().toObjectId());
assertEquals(commit, subDiff.getNewId().toObjectId());
assertEquals(path, subDiff.getNewPath());
}
@Test
public void commitSubmoduleUpdate() throws Exception {
Git git = new Git(db);
writeTrashFile("file.txt", "content");
git.add().addFilepattern("file.txt").call();
RevCommit commit = git.commit().setMessage("create file").call();
writeTrashFile("file.txt", "content2");
git.add().addFilepattern("file.txt").call();
RevCommit commit2 = git.commit().setMessage("edit file").call();
SubmoduleAddCommand command = new SubmoduleAddCommand(db);
String path = "sub";
command.setPath(path);
String uri = db.getDirectory().toURI().toString();
command.setURI(uri);
Repository repo = command.call();
assertNotNull(repo);
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals(path, generator.getPath());
assertEquals(commit2, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
assertNotNull(generator.getRepository());
assertEquals(commit2, repo.resolve(Constants.HEAD));
RevCommit submoduleAddCommit = git.commit().setMessage("submodule add")
.setOnly(path).call();
assertNotNull(submoduleAddCommit);
RefUpdate update = repo.updateRef(Constants.HEAD);
update.setNewObjectId(commit);
assertEquals(Result.FORCED, update.forceUpdate());
RevCommit submoduleEditCommit = git.commit()
.setMessage("submodule add").setOnly(path).call();
assertNotNull(submoduleEditCommit);
TreeWalk walk = new TreeWalk(db);
walk.addTree(submoduleAddCommit.getTree());
walk.addTree(submoduleEditCommit.getTree());
walk.setFilter(TreeFilter.ANY_DIFF);
List<DiffEntry> diffs = DiffEntry.scan(walk);
assertEquals(1, diffs.size());
DiffEntry subDiff = diffs.get(0);
assertEquals(FileMode.GITLINK, subDiff.getOldMode());
assertEquals(FileMode.GITLINK, subDiff.getNewMode());
assertEquals(commit2, subDiff.getOldId().toObjectId());
assertEquals(commit, subDiff.getNewId().toObjectId());
assertEquals(path, subDiff.getNewPath());
assertEquals(path, subDiff.getOldPath());
}
}

103
org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleWalkTest.java

@ -44,10 +44,12 @@ package org.eclipse.jgit.submodule;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import org.eclipse.jgit.dircache.DirCache;
@ -58,7 +60,9 @@ import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryTestCase;
import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
import org.eclipse.jgit.treewalk.filter.PathFilter;
import org.junit.Test;
@ -97,8 +101,6 @@ public class SubmoduleWalkTest extends RepositoryTestCase {
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertEquals(new File(db.getWorkTree(), path + File.separatorChar
+ Constants.DOT_GIT), gen.getGitDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
@ -108,6 +110,101 @@ public class SubmoduleWalkTest extends RepositoryTestCase {
assertFalse(gen.next());
}
@Test
public void repositoryWithRootLevelSubmoduleAbsoluteRef()
throws IOException, ConfigInvalidException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
File dotGit = new File(db.getWorkTree(), path + File.separatorChar
+ Constants.DOT_GIT);
if (!dotGit.getParentFile().exists())
dotGit.getParentFile().mkdirs();
File modulesGitDir = new File(db.getDirectory(), "modules"
+ File.separatorChar + path);
new FileWriter(dotGit).append(
"gitdir: " + modulesGitDir.getAbsolutePath()).close();
FileRepositoryBuilder builder = new FileRepositoryBuilder();
builder.setWorkTree(new File(db.getWorkTree(), path));
builder.build().create();
DirCache cache = db.lockDirCache();
DirCacheEditor editor = cache.editor();
editor.add(new PathEdit(path) {
public void apply(DirCacheEntry ent) {
ent.setFileMode(FileMode.GITLINK);
ent.setObjectId(id);
}
});
editor.commit();
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
Repository subRepo = gen.getRepository();
assertNotNull(subRepo);
assertEquals(modulesGitDir, subRepo.getDirectory());
assertEquals(new File(db.getWorkTree(), path), subRepo.getWorkTree());
assertFalse(gen.next());
}
@Test
public void repositoryWithRootLevelSubmoduleRelativeRef()
throws IOException, ConfigInvalidException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
File dotGit = new File(db.getWorkTree(), path + File.separatorChar
+ Constants.DOT_GIT);
if (!dotGit.getParentFile().exists())
dotGit.getParentFile().mkdirs();
File modulesGitDir = new File(db.getDirectory(), "modules"
+ File.separatorChar + path);
new FileWriter(dotGit).append(
"gitdir: " + "../" + Constants.DOT_GIT + "/modules/" + path)
.close();
FileRepositoryBuilder builder = new FileRepositoryBuilder();
builder.setWorkTree(new File(db.getWorkTree(), path));
builder.build().create();
DirCache cache = db.lockDirCache();
DirCacheEditor editor = cache.editor();
editor.add(new PathEdit(path) {
public void apply(DirCacheEntry ent) {
ent.setFileMode(FileMode.GITLINK);
ent.setObjectId(id);
}
});
editor.commit();
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
Repository subRepo = gen.getRepository();
assertNotNull(subRepo);
assertEquals(modulesGitDir, subRepo.getDirectory());
assertEquals(new File(db.getWorkTree(), path), subRepo.getWorkTree());
assertFalse(gen.next());
}
@Test
public void repositoryWithNestedSubmodule() throws IOException,
ConfigInvalidException {
@ -130,8 +227,6 @@ public class SubmoduleWalkTest extends RepositoryTestCase {
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertEquals(new File(db.getWorkTree(), path + File.separatorChar
+ Constants.DOT_GIT), gen.getGitDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());

1
org.eclipse.jgit/resources/org/eclipse/jgit/JGitText.properties

@ -234,6 +234,7 @@ invalidChannel=Invalid channel {0}
invalidCharacterInBase64Data=Invalid character in Base64 data.
invalidCommitParentNumber=Invalid commit parent number
invalidEncryption=Invalid encryption
invalidGitdirRef = Invalid .git reference in file ''{0}''
invalidGitType=invalid git type: {0}
invalidId=Invalid id {0}
invalidIdLength=Invalid id length {0}; should be {1}

1
org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java

@ -294,6 +294,7 @@ public class JGitText extends TranslationBundle {
/***/ public String invalidCharacterInBase64Data;
/***/ public String invalidCommitParentNumber;
/***/ public String invalidEncryption;
/***/ public String invalidGitdirRef;
/***/ public String invalidGitType;
/***/ public String invalidId;
/***/ public String invalidIdLength;

9
org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java

@ -351,12 +351,9 @@ public class CommitCommand extends GitCommand<RevCommit> {
if (objectExists) {
dcEntry.setObjectId(fTree.getEntryObjectId());
} else {
if (FileMode.GITLINK.equals(dcEntry.getFileMode())) {
// Do not check the content of submodule entries
// Use the old entry information instead.
dcEntry.copyMetaData(index.getEntry(dcEntry
.getPathString()));
} else {
if (FileMode.GITLINK.equals(dcEntry.getFileMode()))
dcEntry.setObjectId(fTree.getEntryObjectId());
else {
// insert object
if (inserter == null)
inserter = repo.newObjectInserter();

50
org.eclipse.jgit/src/org/eclipse/jgit/lib/BaseRepositoryBuilder.java

@ -69,6 +69,8 @@ import org.eclipse.jgit.storage.file.FileBasedConfig;
import org.eclipse.jgit.storage.file.FileRepository;
import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
import org.eclipse.jgit.util.FS;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.RawParseUtils;
import org.eclipse.jgit.util.SystemReader;
/**
@ -85,6 +87,19 @@ import org.eclipse.jgit.util.SystemReader;
* @see FileRepositoryBuilder
*/
public class BaseRepositoryBuilder<B extends BaseRepositoryBuilder, R extends Repository> {
private static boolean isSymRef(byte[] ref) {
if (ref.length < 9)
return false;
return /**/ref[0] == 'g' //
&& ref[1] == 'i' //
&& ref[2] == 't' //
&& ref[3] == 'd' //
&& ref[4] == 'i' //
&& ref[5] == 'r' //
&& ref[6] == ':' //
&& ref[7] == ' ';
}
private FS fs;
private File gitDir;
@ -546,10 +561,37 @@ public class BaseRepositoryBuilder<B extends BaseRepositoryBuilder, R extends Re
* the repository could not be accessed
*/
protected void setupGitDir() throws IOException {
// No gitDir? Try to assume its under the workTree.
//
if (getGitDir() == null && getWorkTree() != null)
setGitDir(new File(getWorkTree(), DOT_GIT));
// No gitDir? Try to assume its under the workTree or a ref to another
// location
if (getGitDir() == null && getWorkTree() != null) {
File dotGit = new File(getWorkTree(), DOT_GIT);
if (!dotGit.isFile())
setGitDir(dotGit);
else {
byte[] content = IO.readFully(dotGit);
if (!isSymRef(content))
throw new IOException(MessageFormat.format(
JGitText.get().invalidGitdirRef,
dotGit.getAbsolutePath()));
int pathStart = 8;
int lineEnd = RawParseUtils.nextLF(content, pathStart);
if (content[lineEnd - 1] == '\n')
lineEnd--;
if (lineEnd == pathStart)
throw new IOException(MessageFormat.format(
JGitText.get().invalidGitdirRef,
dotGit.getAbsolutePath()));
String gitdirPath = RawParseUtils.decode(content, pathStart,
lineEnd);
File gitdirFile = new File(gitdirPath);
if (gitdirFile.isAbsolute())
setGitDir(gitdirFile);
else
setGitDir(new File(getWorkTree(), gitdirPath)
.getCanonicalFile());
}
}
}
/**

53
org.eclipse.jgit/src/org/eclipse/jgit/submodule/SubmoduleWalk.java

@ -155,27 +155,32 @@ public class SubmoduleWalk {
*/
public static Repository getSubmoduleRepository(final Repository parent,
final String path) throws IOException {
File directory = getSubmoduleGitDirectory(parent, path);
if (!directory.isDirectory())
return null;
try {
return new RepositoryBuilder().setMustExist(true)
.setFS(FS.DETECTED).setGitDir(directory).build();
} catch (RepositoryNotFoundException e) {
return null;
}
return getSubmoduleRepository(parent.getWorkTree(), path);
}
/**
* Get the .git directory for a repository submodule path
* Get submodule repository at path
*
* @param parent
* @param path
* @return .git for submodule repository
* @return repository or null if repository doesn't exist
* @throws IOException
*/
public static File getSubmoduleGitDirectory(final Repository parent,
final String path) {
return new File(getSubmoduleDirectory(parent, path), Constants.DOT_GIT);
public static Repository getSubmoduleRepository(final File parent,
final String path) throws IOException {
File subWorkTree = new File(parent, path);
if (!subWorkTree.isDirectory())
return null;
File workTree = new File(parent, path);
try {
return new RepositoryBuilder() //
.setMustExist(true) //
.setFS(FS.DETECTED) //
.setWorkTree(workTree) //
.build();
} catch (RepositoryNotFoundException e) {
return null;
}
}
/**
@ -348,15 +353,6 @@ public class SubmoduleWalk {
return getSubmoduleDirectory(repository, path);
}
/**
* Get the .git directory for the current submodule entry
*
* @return .git for submodule repository
*/
public File getGitDirectory() {
return getSubmoduleGitDirectory(repository, path);
}
/**
* Advance to next submodule in the index tree.
*
@ -466,20 +462,9 @@ public class SubmoduleWalk {
ConfigConstants.CONFIG_KEY_UPDATE);
}
/**
* Does the current submodule entry have a .git directory in the parent
* repository's working tree?
*
* @return true if .git directory exists, false otherwise
*/
public boolean hasGitDirectory() {
return getGitDirectory().isDirectory();
}
/**
* Get repository for current submodule entry
*
* @see #hasGitDirectory()
* @return repository or null if non-existent
* @throws IOException
*/

2
org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java

@ -159,7 +159,7 @@ public class FileTreeIterator extends WorkingTreeIterator {
file = f;
if (f.isDirectory()) {
if (new File(f, Constants.DOT_GIT).isDirectory())
if (new File(f, Constants.DOT_GIT).exists())
mode = FileMode.GITLINK;
else
mode = FileMode.TREE;

14
org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java

@ -76,7 +76,7 @@ import org.eclipse.jgit.lib.CoreConfig.AutoCRLF;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryBuilder;
import org.eclipse.jgit.submodule.SubmoduleWalk;
import org.eclipse.jgit.util.FS;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.io.EolCanonicalizingInputStream;
@ -280,18 +280,16 @@ public abstract class WorkingTreeIterator extends AbstractTreeIterator {
* @return non-null submodule id
*/
protected byte[] idSubmodule(File directory, Entry e) {
final String gitDirPath = e.getName() + "/" + Constants.DOT_GIT;
final File submoduleGitDir = new File(directory, gitDirPath);
if (!submoduleGitDir.isDirectory())
return zeroid;
final Repository submoduleRepo;
try {
FS fs = repository != null ? repository.getFS() : FS.DETECTED;
submoduleRepo = new RepositoryBuilder().setGitDir(submoduleGitDir)
.setMustExist(true).setFS(fs).build();
submoduleRepo = SubmoduleWalk.getSubmoduleRepository(directory,
e.getName());
} catch (IOException exception) {
return zeroid;
}
if (submoduleRepo == null)
return zeroid;
final ObjectId head;
try {
head = submoduleRepo.resolve(Constants.HEAD);

Loading…
Cancel
Save