motiejus
/
jgit
1
Fork 0
Code Releases Activity

Support for Submodule configuration submodule.<name>.ignore 

For each submodule native git allows to configure which modifications to
submodules should be ignored by the status command. It is possible to
ignore "none", "all", "dirty", "untracked" [1]. This configuration is
now supported by IndexDiff. The StatusCommand offers the possibility to
specify this mode.

[1] http://git-scm.com/docs/gitmodules

Change-Id: Ifd81d574a680f9b4152945ba70f8ec4af4f452c9
This commit is contained in:
Christian Halstrick 2014-10-17 09:58:39 +02:00 committed by Stefan Lay
parent 2f5a08798e
commit 95172dea17
5 changed files with 378 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/IndexDiffSubmoduleTest.java Normal file
View File

@ -0,0 +1,211 @@
/*
* Copyright (C) 2014, Christian Halstrick <christian.halstrick@sap.com>
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.lib;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.errors.NoWorkTreeException;
import org.eclipse.jgit.internal.storage.file.FileRepository;
import org.eclipse.jgit.junit.JGitTestUtil;
import org.eclipse.jgit.junit.RepositoryTestCase;
import org.eclipse.jgit.submodule.SubmoduleWalk.IgnoreSubmoduleMode;
import org.eclipse.jgit.treewalk.FileTreeIterator;
import org.junit.Before;
import org.junit.experimental.theories.DataPoints;
import org.junit.experimental.theories.Theories;
import org.junit.experimental.theories.Theory;
import org.junit.runner.RunWith;
@RunWith(Theories.class)
public class IndexDiffSubmoduleTest extends RepositoryTestCase {
/** a submodule repository inside a root repository */
protected FileRepository submodule_db;
/** Working directory of the submodule repository */
protected File submodule_trash;
@DataPoints
public static IgnoreSubmoduleMode allModes[] = IgnoreSubmoduleMode.values();
@Override
@Before
public void setUp() throws Exception {
super.setUp();
FileRepository submoduleStandalone = createWorkRepository();
JGitTestUtil.writeTrashFile(submoduleStandalone, "fileInSubmodule",
"submodule");
Git submoduleStandaloneGit = Git.wrap(submoduleStandalone);
submoduleStandaloneGit.add().addFilepattern("fileInSubmodule").call();
submoduleStandaloneGit.commit().setMessage("add file to submodule")
.call();
submodule_db = (FileRepository) Git.wrap(db).submoduleAdd()
.setPath("submodule")
.setURI(submoduleStandalone.getDirectory().toURI().toString())
.call();
submodule_trash = submodule_db.getWorkTree();
writeTrashFile("fileInRoot", "root");
Git rootGit = Git.wrap(db);
rootGit.add().addFilepattern("fileInRoot").call();
rootGit.commit().setMessage("add submodule and root file").call();
}
@Theory
public void testInitiallyClean(IgnoreSubmoduleMode mode)
throws IOException {
IndexDiff indexDiff = new IndexDiff(db, Constants.HEAD,
new FileTreeIterator(db));
indexDiff.setIgnoreSubmoduleMode(mode);
assertFalse(indexDiff.diff());
}
@Theory
public void testDirtyRootWorktree(IgnoreSubmoduleMode mode)
throws IOException {
writeTrashFile("fileInRoot", "2");
IndexDiff indexDiff = new IndexDiff(db, Constants.HEAD,
new FileTreeIterator(db));
indexDiff.setIgnoreSubmoduleMode(mode);
assertTrue(indexDiff.diff());
}
@Theory
public void testDirtySubmoduleWorktree(IgnoreSubmoduleMode mode)
throws IOException {
JGitTestUtil.writeTrashFile(submodule_db, "fileInSubmodule", "2");
IndexDiff indexDiff = new IndexDiff(db, Constants.HEAD,
new FileTreeIterator(db));
indexDiff.setIgnoreSubmoduleMode(mode);
if (mode.equals(IgnoreSubmoduleMode.ALL)
|| mode.equals(IgnoreSubmoduleMode.DIRTY))
assertFalse("diff should be false with mode=" + mode,
indexDiff.diff());
else
assertTrue("diff should be true with mode=" + mode,
indexDiff.diff());
}
@Theory
public void testDirtySubmoduleHEAD(IgnoreSubmoduleMode mode)
throws IOException, GitAPIException {
JGitTestUtil.writeTrashFile(submodule_db, "fileInSubmodule", "2");
Git submoduleGit = Git.wrap(submodule_db);
submoduleGit.add().addFilepattern("fileInSubmodule").call();
submoduleGit.commit().setMessage("Modified fileInSubmodule").call();
IndexDiff indexDiff = new IndexDiff(db, Constants.HEAD,
new FileTreeIterator(db));
indexDiff.setIgnoreSubmoduleMode(mode);
if (mode.equals(IgnoreSubmoduleMode.ALL))
assertFalse("diff should be false with mode=" + mode,
indexDiff.diff());
else
assertTrue("diff should be true with mode=" + mode,
indexDiff.diff());
}
@Theory
public void testDirtySubmoduleIndex(IgnoreSubmoduleMode mode)
throws IOException, GitAPIException {
JGitTestUtil.writeTrashFile(submodule_db, "fileInSubmodule", "2");
Git submoduleGit = Git.wrap(submodule_db);
submoduleGit.add().addFilepattern("fileInSubmodule").call();
IndexDiff indexDiff = new IndexDiff(db, Constants.HEAD,
new FileTreeIterator(db));
indexDiff.setIgnoreSubmoduleMode(mode);
if (mode.equals(IgnoreSubmoduleMode.ALL)
|| mode.equals(IgnoreSubmoduleMode.DIRTY))
assertFalse("diff should be false with mode=" + mode,
indexDiff.diff());
else
assertTrue("diff should be true with mode=" + mode,
indexDiff.diff());
}
@Theory
public void testDirtySubmoduleIndexAndWorktree(IgnoreSubmoduleMode mode)
throws IOException, GitAPIException, NoWorkTreeException {
JGitTestUtil.writeTrashFile(submodule_db, "fileInSubmodule", "2");
Git submoduleGit = Git.wrap(submodule_db);
submoduleGit.add().addFilepattern("fileInSubmodule").call();
JGitTestUtil.writeTrashFile(submodule_db, "fileInSubmodule", "3");
IndexDiff indexDiff = new IndexDiff(db, Constants.HEAD,
new FileTreeIterator(db));
indexDiff.setIgnoreSubmoduleMode(mode);
if (mode.equals(IgnoreSubmoduleMode.ALL)
|| mode.equals(IgnoreSubmoduleMode.DIRTY))
assertFalse("diff should be false with mode=" + mode,
indexDiff.diff());
else
assertTrue("diff should be true with mode=" + mode,
indexDiff.diff());
}
@Theory
public void testDirtySubmoduleWorktreeUntracked(IgnoreSubmoduleMode mode)
throws IOException {
JGitTestUtil.writeTrashFile(submodule_db, "additionalFileInSubmodule",
"2");
IndexDiff indexDiff = new IndexDiff(db, Constants.HEAD,
new FileTreeIterator(db));
indexDiff.setIgnoreSubmoduleMode(mode);
if (mode.equals(IgnoreSubmoduleMode.ALL)
|| mode.equals(IgnoreSubmoduleMode.DIRTY)
|| mode.equals(IgnoreSubmoduleMode.UNTRACKED))
assertFalse("diff should be false with mode=" + mode,
indexDiff.diff());
else
assertTrue("diff should be true with mode=" + mode,
indexDiff.diff());
}
}

14
org.eclipse.jgit/src/org/eclipse/jgit/api/StatusCommand.java
View File

@ -53,6 +53,7 @@
import org.eclipse.jgit.lib.IndexDiff;
import org.eclipse.jgit.lib.ProgressMonitor;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.submodule.SubmoduleWalk.IgnoreSubmoduleMode;
import org.eclipse.jgit.treewalk.FileTreeIterator;
import org.eclipse.jgit.treewalk.WorkingTreeIterator;
import org.eclipse.jgit.treewalk.filter.PathFilterGroup;
@ -72,6 +73,8 @@ public class StatusCommand extends GitCommand<Status> {
private List<String> paths = null;
private ProgressMonitor progressMonitor = null;
private IgnoreSubmoduleMode ignoreSubmoduleMode = null;
/**
* @param repo
*/
@ -79,6 +82,15 @@ protected StatusCommand(Repository repo) {
super(repo);
}
/**
* @param mode
* @return {@code this}
*/
public StatusCommand setIgnoreSubmodules(IgnoreSubmoduleMode mode) {
ignoreSubmoduleMode = mode;
return this;
}
/**
* Show only the status of files which match the given paths. The path must
* either name a file or a directory exactly. All paths are always relative
@ -127,6 +139,8 @@ public Status call() throws GitAPIException, NoWorkTreeException {
try {
IndexDiff diff = new IndexDiff(repo, Constants.HEAD, workingTreeIt);
if (ignoreSubmoduleMode != null)
diff.setIgnoreSubmoduleMode(ignoreSubmoduleMode);
if (paths != null)
diff.setFilter(PathFilterGroup.createFromStrings(paths));
if (progressMonitor == null)

3
org.eclipse.jgit/src/org/eclipse/jgit/lib/ConfigConstants.java
View File

@ -208,6 +208,9 @@ public class ConfigConstants {
/** The "update" key */
public static final String CONFIG_KEY_UPDATE = "update";
/** The "update" key */
public static final String CONFIG_KEY_IGNORE = "ignore";
/** The "compression" key */
public static final String CONFIG_KEY_COMPRESSION = "compression";

118
org.eclipse.jgit/src/org/eclipse/jgit/lib/IndexDiff.java
View File

@ -58,13 +58,17 @@
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.dircache.DirCacheIterator;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.StopWalkException;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.submodule.SubmoduleWalk;
import org.eclipse.jgit.submodule.SubmoduleWalk.IgnoreSubmoduleMode;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.EmptyTreeIterator;
import org.eclipse.jgit.treewalk.FileTreeIterator;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.jgit.treewalk.WorkingTreeIterator;
import org.eclipse.jgit.treewalk.filter.AndTreeFilter;
@ -268,6 +272,10 @@ public TreeFilter clone() {
private IndexDiffFilter indexDiffFilter;
private Map<String, IndexDiff> submoduleIndexDiffs = new HashMap<String, IndexDiff>();
private IgnoreSubmoduleMode ignoreSubmoduleMode = null;
/**
* Construct an IndexDiff
*
@ -281,13 +289,7 @@ public TreeFilter clone() {
*/
public IndexDiff(Repository repository, String revstr,
WorkingTreeIterator workingTreeIterator) throws IOException {
this.repository = repository;
ObjectId objectId = repository.resolve(revstr);
if (objectId != null)
tree = new RevWalk(repository).parseTree(objectId);
else
tree = null;
this.initialWorkingTreeIterator = workingTreeIterator;
this(repository, repository.resolve(revstr), workingTreeIterator);
}
/**
@ -310,6 +312,40 @@ public IndexDiff(Repository repository, ObjectId objectId,
this.initialWorkingTreeIterator = workingTreeIterator;
}
/**
* @param mode
* defines how modifications in submodules are treated
*/
public void setIgnoreSubmoduleMode(IgnoreSubmoduleMode mode) {
this.ignoreSubmoduleMode = mode;
}
/**
* A factory to producing WorkingTreeIterators
*/
public interface WorkingTreeIteratorFactory {
/**
* @param repo
* @return a WorkingTreeIterator for repo
*/
public WorkingTreeIterator getWorkingTreeIterator(Repository repo);
}
private WorkingTreeIteratorFactory wTreeIt = new WorkingTreeIteratorFactory() {
public WorkingTreeIterator getWorkingTreeIterator(Repository repo) {
return new FileTreeIterator(repo);
}
};
/**
* Allows higher layers to set the factory for WorkingTreeIterators.
*
* @param wTreeIt
*/
public void setWorkingTreeItFactory(WorkingTreeIteratorFactory wTreeIt) {
this.wTreeIt = wTreeIt;
}
/**
* Sets a filter. Can be used e.g. for restricting the tree walk to a set of
* files.
@ -413,18 +449,25 @@ public boolean diff(final ProgressMonitor monitor, int estWorkTreeSize,
|| treeIterator.getEntryRawMode()
!= dirCacheIterator.getEntryRawMode()) {
// in repo, in index, content diff => changed
changed.add(treeWalk.getPathString());
if (!isEntryGitLink(treeIterator)
|| !isEntryGitLink(dirCacheIterator)
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
changed.add(treeWalk.getPathString());
}
} else {
// in repo, not in index => removed
removed.add(treeWalk.getPathString());
if (!isEntryGitLink(treeIterator)
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
removed.add(treeWalk.getPathString());
if (workingTreeIterator != null)
untracked.add(treeWalk.getPathString());
}
} else {
if (dirCacheIterator != null) {
// not in repo, in index => added
added.add(treeWalk.getPathString());
if (!isEntryGitLink(dirCacheIterator)
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
added.add(treeWalk.getPathString());
} else {
// not in repo, not in index => untracked
if (workingTreeIterator != null
@ -437,13 +480,59 @@ public boolean diff(final ProgressMonitor monitor, int estWorkTreeSize,
if (dirCacheIterator != null) {
if (workingTreeIterator == null) {
// in index, not in workdir => missing
missing.add(treeWalk.getPathString());
if (!isEntryGitLink(dirCacheIterator)
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
missing.add(treeWalk.getPathString());
} else {
if (workingTreeIterator.isModified(
dirCacheIterator.getDirCacheEntry(), true,
treeWalk.getObjectReader())) {
// in index, in workdir, content differs => modified
modified.add(treeWalk.getPathString());
if (!isEntryGitLink(dirCacheIterator) || !isEntryGitLink(workingTreeIterator)
|| (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL && ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
modified.add(treeWalk.getPathString());
}
}
}
}
if (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL) {
IgnoreSubmoduleMode localIgnoreSubmoduleMode = ignoreSubmoduleMode;
SubmoduleWalk smw = SubmoduleWalk.forIndex(repository);
while (smw.next()) {
try {
if (localIgnoreSubmoduleMode == null)
localIgnoreSubmoduleMode = smw.getModulesIgnore();
if (IgnoreSubmoduleMode.ALL
.equals(localIgnoreSubmoduleMode))
continue;
} catch (ConfigInvalidException e) {
throw new IOException(
"Found invalid ignore param for submodule "
+ smw.getPath());
}
Repository subRepo = smw.getRepository();
ObjectId subHead = subRepo.resolve("HEAD");
if (subHead != null && !subHead.equals(smw.getObjectId()))
modified.add(smw.getPath());
else if (ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY) {
IndexDiff smid = submoduleIndexDiffs.get(smw.getPath());
if (smid == null) {
smid = new IndexDiff(subRepo, smw.getObjectId(),
wTreeIt.getWorkingTreeIterator(subRepo));
submoduleIndexDiffs.put(smw.getPath(), smid);
}
if (smid.diff()) {
if (ignoreSubmoduleMode == IgnoreSubmoduleMode.UNTRACKED
&& smid.getAdded().isEmpty()
&& smid.getChanged().isEmpty()
&& smid.getConflicting().isEmpty()
&& smid.getMissing().isEmpty()
&& smid.getModified().isEmpty()
&& smid.getRemoved().isEmpty()) {
continue;
}
modified.add(smw.getPath());
}
}
}
@ -462,6 +551,11 @@ public boolean diff(final ProgressMonitor monitor, int estWorkTreeSize,
return true;
}
private boolean isEntryGitLink(AbstractTreeIterator ti) {
return ((ti != null) && (ti.getEntryRawMode() == FileMode.GITLINK
.getBits()));
}
private void addConflict(String path, int stage) {
StageState existingStageStates = conflicts.get(path);
byte stageMask = 0;

44
org.eclipse.jgit/src/org/eclipse/jgit/submodule/SubmoduleWalk.java
View File

@ -78,6 +78,31 @@
*/
public class SubmoduleWalk {
/**
* The values for the config param submodule.<name>.ignore
*/
public enum IgnoreSubmoduleMode {
/**
* Ignore all modifications to submodules
*/
ALL,
/**
* Ignore changes to the working tree of a submodule
*/
DIRTY,
/**
* Ignore changes to untracked files in the working tree of a submodule
*/
UNTRACKED,
/**
* Ignore nothing. That's the default
*/
NONE;
}
/**
* Create a generator to walk over the submodule entries currently in the
* index
@ -599,6 +624,25 @@ public String getModulesUpdate() throws IOException, ConfigInvalidException {
ConfigConstants.CONFIG_KEY_UPDATE);
}
/**
* Get the configured ignore field for the current entry. This will be the
* value from the .gitmodules file in the current repository's working tree.
*
* @return ignore value
* @throws ConfigInvalidException
* @throws IOException
*/
public IgnoreSubmoduleMode getModulesIgnore() throws IOException,
ConfigInvalidException {
lazyLoadModulesConfig();
String name = modulesConfig.getString(
ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
ConfigConstants.CONFIG_KEY_IGNORE);
if (name == null)
return null;
return IgnoreSubmoduleMode.valueOf(name.trim().toUpperCase());
}
/**
* Get repository for current submodule entry
*