Merge "Retain executable mode of existing files on Windows"

6 files changed, 286 insertions, 4 deletions

diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/AddCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/AddCommandTest.java
index 61b099d61d..632732db8f 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/AddCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/AddCommandTest.java
@@ -44,6 +44,7 @@
 package org.eclipse.jgit.api;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.fail;
 
 import java.io.File;
@@ -55,11 +56,16 @@ import org.eclipse.jgit.api.errors.NoFilepatternException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheBuilder;
 import org.eclipse.jgit.dircache.DirCacheEntry;
+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.ObjectInserter;
 import org.eclipse.jgit.lib.RepositoryTestCase;
+import org.eclipse.jgit.lib.StoredConfig;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.util.FS;
 import org.eclipse.jgit.util.FileUtils;
 import org.junit.Test;
 
@@ -509,6 +515,98 @@ public class AddCommandTest extends RepositoryTestCase {
 				| ASSUME_UNCHANGED));
 	}
 
+	@Test
+	public void testExecutableRetention() throws Exception {
+		StoredConfig config = db.getConfig();
+		config.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
+				ConfigConstants.CONFIG_KEY_FILEMODE, true);
+		config.save();
+
+		FS executableFs = new FS() {
+
+			public boolean supportsExecute() {
+				return true;
+			}
+
+			public boolean setExecute(File f, boolean canExec) {
+				return true;
+			}
+
+			public ProcessBuilder runInShell(String cmd, String[] args) {
+				return null;
+			}
+
+			public boolean retryFailedLockFileCommit() {
+				return false;
+			}
+
+			public FS newInstance() {
+				return this;
+			}
+
+			protected File discoverGitPrefix() {
+				return null;
+			}
+
+			public boolean canExecute(File f) {
+				return true;
+			}
+		};
+
+		Git git = Git.open(db.getDirectory(), executableFs);
+		String path = "a.txt";
+		writeTrashFile(path, "content");
+		git.add().addFilepattern(path).call();
+		RevCommit commit1 = git.commit().setMessage("commit").call();
+		TreeWalk walk = TreeWalk.forPath(db, path, commit1.getTree());
+		assertNotNull(walk);
+		assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
+
+		FS nonExecutableFs = new FS() {
+
+			public boolean supportsExecute() {
+				return false;
+			}
+
+			public boolean setExecute(File f, boolean canExec) {
+				return false;
+			}
+
+			public ProcessBuilder runInShell(String cmd, String[] args) {
+				return null;
+			}
+
+			public boolean retryFailedLockFileCommit() {
+				return false;
+			}
+
+			public FS newInstance() {
+				return this;
+			}
+
+			protected File discoverGitPrefix() {
+				return null;
+			}
+
+			public boolean canExecute(File f) {
+				return false;
+			}
+		};
+
+		config = db.getConfig();
+		config.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
+				ConfigConstants.CONFIG_KEY_FILEMODE, false);
+		config.save();
+
+		Git git2 = Git.open(db.getDirectory(), nonExecutableFs);
+		writeTrashFile(path, "content2");
+		git2.add().addFilepattern(path).call();
+		RevCommit commit2 = git2.commit().setMessage("commit2").call();
+		walk = TreeWalk.forPath(db, path, commit2.getTree());
+		assertNotNull(walk);
+		assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
+	}
+
 	private DirCacheEntry addEntryToBuilder(String path, File file,
 			ObjectInserter newObjectInserter, DirCacheBuilder builder, int stage)
 			throws IOException {
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
new file mode 100644
index 0000000000..37fbc67cab
--- /dev/null
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2011, GitHub Inc.
+ * 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.api;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.File;
+
+import org.eclipse.jgit.lib.ConfigConstants;
+import org.eclipse.jgit.lib.FileMode;
+import org.eclipse.jgit.lib.RepositoryTestCase;
+import org.eclipse.jgit.lib.StoredConfig;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.util.FS;
+import org.junit.Test;
+
+/**
+ * Unit tests of {@link CommitCommand}
+ */
+public class CommitCommandTest extends RepositoryTestCase {
+
+	@Test
+	public void testExecutableRetention() throws Exception {
+		StoredConfig config = db.getConfig();
+		config.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
+				ConfigConstants.CONFIG_KEY_FILEMODE, true);
+		config.save();
+
+		FS executableFs = new FS() {
+
+			public boolean supportsExecute() {
+				return true;
+			}
+
+			public boolean setExecute(File f, boolean canExec) {
+				return true;
+			}
+
+			public ProcessBuilder runInShell(String cmd, String[] args) {
+				return null;
+			}
+
+			public boolean retryFailedLockFileCommit() {
+				return false;
+			}
+
+			public FS newInstance() {
+				return this;
+			}
+
+			protected File discoverGitPrefix() {
+				return null;
+			}
+
+			public boolean canExecute(File f) {
+				return true;
+			}
+		};
+
+		Git git = Git.open(db.getDirectory(), executableFs);
+		String path = "a.txt";
+		writeTrashFile(path, "content");
+		git.add().addFilepattern(path).call();
+		RevCommit commit1 = git.commit().setMessage("commit").call();
+		TreeWalk walk = TreeWalk.forPath(db, path, commit1.getTree());
+		assertNotNull(walk);
+		assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
+
+		FS nonExecutableFs = new FS() {
+
+			public boolean supportsExecute() {
+				return false;
+			}
+
+			public boolean setExecute(File f, boolean canExec) {
+				return false;
+			}
+
+			public ProcessBuilder runInShell(String cmd, String[] args) {
+				return null;
+			}
+
+			public boolean retryFailedLockFileCommit() {
+				return false;
+			}
+
+			public FS newInstance() {
+				return this;
+			}
+
+			protected File discoverGitPrefix() {
+				return null;
+			}
+
+			public boolean canExecute(File f) {
+				return false;
+			}
+		};
+
+		config = db.getConfig();
+		config.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
+				ConfigConstants.CONFIG_KEY_FILEMODE, false);
+		config.save();
+
+		Git git2 = Git.open(db.getDirectory(), nonExecutableFs);
+		writeTrashFile(path, "content2");
+		RevCommit commit2 = git2.commit().setOnly(path).setMessage("commit2")
+				.call();
+		walk = TreeWalk.forPath(db, path, commit2.getTree());
+		assertNotNull(walk);
+		assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
+	}
+}
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java
index 7e670304d9..f3e47ae011 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java
@@ -171,7 +171,7 @@ public class AddCommand extends GitCommand<DirCache> {
 							DirCacheEntry entry = new DirCacheEntry(path);
 							if (c == null || c.getDirCacheEntry() == null
 									|| !c.getDirCacheEntry().isAssumeValid()) {
-								FileMode mode = f.getEntryFileMode();
+								FileMode mode = f.getIndexFileMode(c);
 								entry.setFileMode(mode);
 
 								if (FileMode.GITLINK != mode) {
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
index 14a7494ba6..a6d780e908 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
@@ -343,7 +343,7 @@ public class CommitCommand extends GitCommand<RevCommit> {
 					long entryLength = fTree.getEntryLength();
 					dcEntry.setLength(entryLength);
 					dcEntry.setLastModified(fTree.getEntryLastModified());
-					dcEntry.setFileMode(fTree.getEntryFileMode());
+					dcEntry.setFileMode(fTree.getIndexFileMode(dcTree));
 
 					boolean objectExists = (dcTree != null && fTree
 							.idEqual(dcTree))
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java
index 7387cb649c..2a42e05d39 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java
@@ -751,6 +751,32 @@ public abstract class WorkingTreeIterator extends AbstractTreeIterator {
 	}
 
 	/**
+	 * Get the file mode to use for the current entry when it is to be updated
+	 * in the index.
+	 *
+	 * @param indexIter
+	 *            {@link DirCacheIterator} positioned at the same entry as this
+	 *            iterator or null if no {@link DirCacheIterator} is available
+	 *            at this iterator's current entry
+	 * @return index file mode
+	 */
+	public FileMode getIndexFileMode(final DirCacheIterator indexIter) {
+		final FileMode wtMode = getEntryFileMode();
+		if (indexIter == null)
+			return wtMode;
+		if (getOptions().isFileMode())
+			return wtMode;
+		final FileMode iMode = indexIter.getEntryFileMode();
+		if (FileMode.REGULAR_FILE == wtMode
+				&& FileMode.EXECUTABLE_FILE == iMode)
+			return iMode;
+		if (FileMode.EXECUTABLE_FILE == wtMode
+				&& FileMode.REGULAR_FILE == iMode)
+			return iMode;
+		return wtMode;
+	}
+
+	/**
 	 * Compares the entries content with the content in the filesystem.
 	 * Unsmudges the entry when it is detected that it is clean.
 	 *
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeOptions.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeOptions.java
index 630d00b376..dafb3a1517 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeOptions.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeOptions.java
@@ -43,6 +43,7 @@
 package org.eclipse.jgit.treewalk;
 
 import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.lib.ConfigConstants;
 import org.eclipse.jgit.lib.Config.SectionParser;
 import org.eclipse.jgit.lib.CoreConfig.AutoCRLF;
 
@@ -60,8 +61,10 @@ public class WorkingTreeOptions {
 	private final AutoCRLF autoCRLF;
 
 	private WorkingTreeOptions(final Config rc) {
-		fileMode = rc.getBoolean("core", "filemode", true);
-		autoCRLF = rc.getEnum("core", null, "autocrlf", AutoCRLF.FALSE);
+		fileMode = rc.getBoolean(ConfigConstants.CONFIG_CORE_SECTION,
+				ConfigConstants.CONFIG_KEY_FILEMODE, true);
+		autoCRLF = rc.getEnum(ConfigConstants.CONFIG_CORE_SECTION, null,
+				ConfigConstants.CONFIG_KEY_AUTOCRLF, AutoCRLF.FALSE);
 	}
 
 	/** @return true if the execute bit on working files should be trusted. */