diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefDatabaseConflictingNamesTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefDatabaseConflictingNamesTest.java new file mode 100644 index 000000000..c88eb3bd9 --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefDatabaseConflictingNamesTest.java @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2013, Robin Stocker + * 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.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.junit.Test; + +public class RefDatabaseConflictingNamesTest { + + private RefDatabase refDatabase = new RefDatabase() { + @Override + public Map getRefs(String prefix) throws IOException { + if (ALL.equals(prefix)) { + Map existing = new HashMap(); + existing.put("refs/heads/a/b", null /* not used */); + existing.put("refs/heads/q", null /* not used */); + return existing; + } else { + return Collections.emptyMap(); + } + } + + @Override + public Ref peel(Ref ref) throws IOException { + return null; + } + + @Override + public RefUpdate newUpdate(String name, boolean detach) + throws IOException { + return null; + } + + @Override + public RefRename newRename(String fromName, String toName) + throws IOException { + return null; + } + + @Override + public boolean isNameConflicting(String name) throws IOException { + return false; + } + + @Override + public Ref getRef(String name) throws IOException { + return null; + } + + @Override + public List getAdditionalRefs() throws IOException { + return null; + } + + @Override + public void create() throws IOException { + // Not needed + } + + @Override + public void close() { + // Not needed + } + }; + + @Test + public void testGetConflictingNames() throws IOException { + // new references cannot replace an existing container + assertConflictingNames("refs", "refs/heads/a/b", "refs/heads/q"); + assertConflictingNames("refs/heads", "refs/heads/a/b", "refs/heads/q"); + assertConflictingNames("refs/heads/a", "refs/heads/a/b"); + + // existing reference is not conflicting + assertNoConflictingNames("refs/heads/a/b"); + + // new references are not conflicting + assertNoConflictingNames("refs/heads/a/d"); + assertNoConflictingNames("refs/heads/master"); + + // existing reference must not be used as a container + assertConflictingNames("refs/heads/a/b/c", "refs/heads/a/b"); + assertConflictingNames("refs/heads/q/master", "refs/heads/q"); + } + + private void assertNoConflictingNames(String proposed) throws IOException { + assertTrue("expected conflicting names to be empty", refDatabase + .getConflictingNames(proposed).isEmpty()); + } + + private void assertConflictingNames(String proposed, String... conflicts) + throws IOException { + Set expected = new HashSet(Arrays.asList(conflicts)); + assertEquals(expected, + new HashSet(refDatabase.getConflictingNames(proposed))); + } +} diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefDatabase.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefDatabase.java index 7e7b779bc..2ee63f18e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefDatabase.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefDatabase.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010, Google Inc. + * Copyright (C) 2010, 2013 Google Inc. * and other copyright owners as documented in the project's IP log. * * This program and the accompanying materials are made available @@ -44,6 +44,9 @@ package org.eclipse.jgit.lib; import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; import java.util.List; import java.util.Map; @@ -111,9 +114,45 @@ public abstract class RefDatabase { * using this name right now would be safe. * @throws IOException * the database could not be read to check for conflicts. + * @see #getConflictingNames(String) */ public abstract boolean isNameConflicting(String name) throws IOException; + /** + * Determine if a proposed reference cannot coexist with existing ones. If + * the passed name already exists, it's not considered a conflict. + * + * @param name + * proposed name to check for conflicts against + * @return a collection of full names of existing refs which would conflict + * with the passed ref name; empty collection when there are no + * conflicts + * @throws IOException + * @since 2.3 + * @see #isNameConflicting(String) + */ + public Collection getConflictingNames(String name) + throws IOException { + Map allRefs = getRefs(ALL); + // Cannot be nested within an existing reference. + int lastSlash = name.lastIndexOf('/'); + while (0 < lastSlash) { + String needle = name.substring(0, lastSlash); + if (allRefs.containsKey(needle)) + return Collections.singletonList(needle); + lastSlash = name.lastIndexOf('/', lastSlash - 1); + } + + List conflicting = new ArrayList(); + // Cannot be the container of an existing reference. + String prefix = name + '/'; + for (String existing : allRefs.keySet()) + if (existing.startsWith(prefix)) + conflicting.add(existing); + + return conflicting; + } + /** * Create a new update command to create, modify or delete a reference. *