diff options
Diffstat (limited to 'org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java')
| -rw-r--r-- | org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java | 406 |
1 files changed, 406 insertions, 0 deletions
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java new file mode 100644 index 0000000000..75cc3bdc5c --- /dev/null +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java @@ -0,0 +1,406 @@ +/* + * Copyright (C) 2007, Dave Watson <dwatson@mimvista.com> + * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com> + * Copyright (C) 2008, Roger C. Soares <rogersoares@intelinet.com.br> + * Copyright (C) 2006, Shawn O. Pearce <spearce@spearce.org> + * 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 java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; + +import org.eclipse.jgit.errors.CheckoutConflictException; +import org.eclipse.jgit.lib.GitIndex.Entry; + +/** + * This class handles checking out one or two trees merging + * with the index (actually a tree too). + * + * Three-way merges are no performed. See {@link #setFailOnConflict(boolean)}. + */ +public class WorkDirCheckout { + Repository repo; + + File root; + + GitIndex index; + + private boolean failOnConflict = true; + + Tree merge; + + + /** + * If <code>true</code>, will scan first to see if it's possible to check out, + * otherwise throw {@link CheckoutConflictException}. If <code>false</code>, + * it will silently deal with the problem. + * @param failOnConflict + */ + public void setFailOnConflict(boolean failOnConflict) { + this.failOnConflict = failOnConflict; + } + + WorkDirCheckout(Repository repo, File workDir, + GitIndex oldIndex, GitIndex newIndex) throws IOException { + this.repo = repo; + this.root = workDir; + this.index = oldIndex; + this.merge = repo.mapTree(newIndex.writeTree()); + } + + /** + * Create a checkout class for checking out one tree, merging with the index + * + * @param repo + * @param root workdir + * @param index current index + * @param merge tree to check out + */ + public WorkDirCheckout(Repository repo, File root, + GitIndex index, Tree merge) { + this.repo = repo; + this.root = root; + this.index = index; + this.merge = merge; + } + + /** + * Create a checkout class for merging and checking our two trees and the index. + * + * @param repo + * @param root workdir + * @param head + * @param index + * @param merge + */ + public WorkDirCheckout(Repository repo, File root, Tree head, GitIndex index, Tree merge) { + this(repo, root, index, merge); + this.head = head; + } + + /** + * Execute this checkout + * + * @throws IOException + */ + public void checkout() throws IOException { + if (head == null) + prescanOneTree(); + else prescanTwoTrees(); + if (!conflicts.isEmpty()) { + if (failOnConflict) { + String[] entries = conflicts.toArray(new String[0]); + throw new CheckoutConflictException(entries); + } + } + + cleanUpConflicts(); + if (head == null) + checkoutOutIndexNoHead(); + else checkoutTwoTrees(); + } + + private void checkoutTwoTrees() throws FileNotFoundException, IOException { + for (String path : removed) { + index.remove(root, new File(root, path)); + } + + for (java.util.Map.Entry<String, ObjectId> entry : updated.entrySet()) { + Entry newEntry = index.addEntry(merge.findBlobMember(entry.getKey())); + index.checkoutEntry(root, newEntry); + } + } + + ArrayList<String> conflicts = new ArrayList<String>(); + ArrayList<String> removed = new ArrayList<String>(); + + Tree head = null; + + HashMap<String, ObjectId> updated = new HashMap<String, ObjectId>(); + + private void checkoutOutIndexNoHead() throws IOException { + new IndexTreeWalker(index, merge, root, new AbstractIndexTreeVisitor() { + public void visitEntry(TreeEntry m, Entry i, File f) throws IOException { + if (m == null) { + index.remove(root, f); + return; + } + + boolean needsCheckout = false; + if (i == null) + needsCheckout = true; + else if (i.getObjectId().equals(m.getId())) { + if (i.isModified(root, true)) + needsCheckout = true; + } else needsCheckout = true; + + if (needsCheckout) { + Entry newEntry = index.addEntry(m); + index.checkoutEntry(root, newEntry); + } + } + }).walk(); + } + + private void cleanUpConflicts() throws CheckoutConflictException { + for (String c : conflicts) { + File conflict = new File(root, c); + if (!conflict.delete()) + throw new CheckoutConflictException("Cannot delete file: " + c); + removeEmptyParents(conflict); + } + for (String r : removed) { + File file = new File(root, r); + file.delete(); + removeEmptyParents(file); + } + } + + private void removeEmptyParents(File f) { + File parentFile = f.getParentFile(); + while (!parentFile.equals(root)) { + if (parentFile.list().length == 0) + parentFile.delete(); + else break; + + parentFile = parentFile.getParentFile(); + } + } + + void prescanOneTree() throws IOException { + new IndexTreeWalker(index, merge, root, new AbstractIndexTreeVisitor() { + public void visitEntry(TreeEntry m, Entry i, File file) throws IOException { + if (m != null) { + if (!file.isFile()) { + checkConflictsWithFile(file); + } + } else { + if (file.exists()) { + removed.add(i.getName()); + conflicts.remove(i.getName()); + } + } + } + }).walk(); + conflicts.removeAll(removed); + } + + private ArrayList<String> listFiles(File file) { + ArrayList<String> list = new ArrayList<String>(); + listFiles(file, list); + return list; + } + + private void listFiles(File dir, ArrayList<String> list) { + for (File f : dir.listFiles()) { + if (f.isDirectory()) + listFiles(f, list); + else { + list.add(Repository.stripWorkDir(root, f)); + } + } + } + + /** + * @return a list of conflicts created by this checkout + */ + public ArrayList<String> getConflicts() { + return conflicts; + } + + /** + * @return a list of all files removed by this checkout + */ + public ArrayList<String> getRemoved() { + return removed; + } + + void prescanTwoTrees() throws IOException { + new IndexTreeWalker(index, head, merge, root, new AbstractIndexTreeVisitor() { + public void visitEntry(TreeEntry treeEntry, TreeEntry auxEntry, + Entry indexEntry, File file) throws IOException { + if (treeEntry instanceof Tree || auxEntry instanceof Tree) { + throw new IllegalArgumentException("Can't pass me a tree!"); + } + processEntry(treeEntry, auxEntry, indexEntry); + } + + @Override + public void finishVisitTree(Tree tree, Tree auxTree, String curDir) throws IOException { + if (curDir.length() == 0) return; + + if (auxTree != null) { + if (index.getEntry(curDir) != null) + removed.add(curDir); + } + } + + }).walk(); + + // if there's a conflict, don't list it under + // to-be-removed, since that messed up our next + // section + removed.removeAll(conflicts); + + for (String path : updated.keySet()) { + if (index.getEntry(path) == null) { + File file = new File(root, path); + if (file.isFile()) + conflicts.add(path); + else if (file.isDirectory()) { + checkConflictsWithFile(file); + } + } + } + + + conflicts.removeAll(removed); + } + + void processEntry(TreeEntry h, TreeEntry m, Entry i) throws IOException { + ObjectId iId = (i == null ? null : i.getObjectId()); + ObjectId mId = (m == null ? null : m.getId()); + ObjectId hId = (h == null ? null : h.getId()); + + String name = (i != null ? i.getName() : + (h != null ? h.getFullName() : + m.getFullName())); + + if (i == null) { + /* + I (index) H M Result + ------------------------------------------------------- + 0 nothing nothing nothing (does not happen) + 1 nothing nothing exists use M + 2 nothing exists nothing remove path from index + 3 nothing exists exists use M */ + + if (h == null) { + updated.put(name,mId); + } else if (m == null) { + removed.add(name); + } else { + updated.put(name, mId); + } + } else if (h == null) { + /* + clean I==H I==M H M Result + ----------------------------------------------------- + 4 yes N/A N/A nothing nothing keep index + 5 no N/A N/A nothing nothing keep index + + 6 yes N/A yes nothing exists keep index + 7 no N/A yes nothing exists keep index + 8 yes N/A no nothing exists fail + 9 no N/A no nothing exists fail */ + + if (m == null || mId.equals(iId)) { + if (hasParentBlob(merge, name)) { + if (i.isModified(root, true)) { + conflicts.add(name); + } else { + removed.add(name); + } + } + } else { + conflicts.add(name); + } + } else if (m == null) { + /* + 10 yes yes N/A exists nothing remove path from index + 11 no yes N/A exists nothing fail + 12 yes no N/A exists nothing fail + 13 no no N/A exists nothing fail + */ + + if (hId.equals(iId)) { + if (i.isModified(root, true)) { + conflicts.add(name); + } else { + removed.add(name); + } + } else { + conflicts.add(name); + } + } else { + if (!hId.equals(mId) && !hId.equals(iId) + && !mId.equals(iId)) { + conflicts.add(name); + } else if (hId.equals(iId) && !mId.equals(iId)) { + if (i.isModified(root, true)) + conflicts.add(name); + else updated.put(name, mId); + } + } + } + + private boolean hasParentBlob(Tree t, String name) throws IOException { + if (name.indexOf("/") == -1) return false; + + String parent = name.substring(0, name.lastIndexOf("/")); + if (t.findBlobMember(parent) != null) + return true; + return hasParentBlob(t, parent); + } + + private void checkConflictsWithFile(File file) { + if (file.isDirectory()) { + ArrayList<String> childFiles = listFiles(file); + conflicts.addAll(childFiles); + } else { + File parent = file.getParentFile(); + while (!parent.equals(root)) { + if (parent.isDirectory()) + break; + if (parent.isFile()) { + conflicts.add(Repository.stripWorkDir(root, parent)); + break; + } + parent = parent.getParentFile(); + } + } + } +} |