| /* |
| * Copyright (C) 2008, 2013 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.transport; |
| |
| import java.io.Serializable; |
| import java.text.MessageFormat; |
| |
| import org.eclipse.jgit.internal.JGitText; |
| import org.eclipse.jgit.lib.Constants; |
| import org.eclipse.jgit.lib.Ref; |
| |
| /** |
| * Describes how refs in one repository copy into another repository. |
| * <p> |
| * A ref specification provides matching support and limited rules to rewrite a |
| * reference in one repository to another reference in another repository. |
| */ |
| public class RefSpec implements Serializable { |
| private static final long serialVersionUID = 1L; |
| |
| /** |
| * Suffix for wildcard ref spec component, that indicate matching all refs |
| * with specified prefix. |
| */ |
| public static final String WILDCARD_SUFFIX = "/*"; //$NON-NLS-1$ |
| |
| /** |
| * Check whether provided string is a wildcard ref spec component. |
| * |
| * @param s |
| * ref spec component - string to test. Can be null. |
| * @return true if provided string is a wildcard ref spec component. |
| */ |
| public static boolean isWildcard(String s) { |
| return s != null && s.contains("*"); //$NON-NLS-1$ |
| } |
| |
| /** Does this specification ask for forced updated (rewind/reset)? */ |
| private boolean force; |
| |
| /** Is this specification actually a wildcard match? */ |
| private boolean wildcard; |
| |
| /** |
| * How strict to be about wildcards. |
| * |
| * @since 4.5 |
| */ |
| public enum WildcardMode { |
| /** |
| * Reject refspecs with an asterisk on the source side and not the |
| * destination side or vice versa. This is the mode used by FetchCommand |
| * and PushCommand to create a one-to-one mapping between source and |
| * destination refs. |
| */ |
| REQUIRE_MATCH, |
| /** |
| * Allow refspecs with an asterisk on only one side. This can create a |
| * many-to-one mapping between source and destination refs, so |
| * expandFromSource and expandFromDestination are not usable in this |
| * mode. |
| */ |
| ALLOW_MISMATCH |
| } |
| /** Whether a wildcard is allowed on one side but not the other. */ |
| private WildcardMode allowMismatchedWildcards; |
| |
| /** Name of the ref(s) we would copy from. */ |
| private String srcName; |
| |
| /** Name of the ref(s) we would copy into. */ |
| private String dstName; |
| |
| /** |
| * Construct an empty RefSpec. |
| * <p> |
| * A newly created empty RefSpec is not suitable for use in most |
| * applications, as at least one field must be set to match a source name. |
| */ |
| public RefSpec() { |
| force = false; |
| wildcard = false; |
| srcName = Constants.HEAD; |
| dstName = null; |
| allowMismatchedWildcards = WildcardMode.REQUIRE_MATCH; |
| } |
| |
| /** |
| * Parse a ref specification for use during transport operations. |
| * <p> |
| * Specifications are typically one of the following forms: |
| * <ul> |
| * <li><code>refs/heads/master</code></li> |
| * <li><code>refs/heads/master:refs/remotes/origin/master</code></li> |
| * <li><code>refs/heads/*:refs/remotes/origin/*</code></li> |
| * <li><code>+refs/heads/master</code></li> |
| * <li><code>+refs/heads/master:refs/remotes/origin/master</code></li> |
| * <li><code>+refs/heads/*:refs/remotes/origin/*</code></li> |
| * <li><code>+refs/pull/*/head:refs/remotes/origin/pr/*</code></li> |
| * <li><code>:refs/heads/master</code></li> |
| * </ul> |
| * |
| * If the wildcard mode allows mismatches, then these ref specs are also |
| * valid: |
| * <ul> |
| * <li><code>refs/heads/*</code></li> |
| * <li><code>refs/heads/*:refs/heads/master</code></li> |
| * </ul> |
| * |
| * @param spec |
| * string describing the specification. |
| * @param mode |
| * whether to allow a wildcard on one side without a wildcard on |
| * the other. |
| * @throws java.lang.IllegalArgumentException |
| * the specification is invalid. |
| * @since 4.5 |
| */ |
| public RefSpec(String spec, WildcardMode mode) { |
| this.allowMismatchedWildcards = mode; |
| String s = spec; |
| if (s.startsWith("+")) { //$NON-NLS-1$ |
| force = true; |
| s = s.substring(1); |
| } |
| |
| final int c = s.lastIndexOf(':'); |
| if (c == 0) { |
| s = s.substring(1); |
| if (isWildcard(s)) { |
| wildcard = true; |
| if (mode == WildcardMode.REQUIRE_MATCH) { |
| throw new IllegalArgumentException(MessageFormat |
| .format(JGitText.get().invalidWildcards, spec)); |
| } |
| } |
| dstName = checkValid(s); |
| } else if (c > 0) { |
| String src = s.substring(0, c); |
| String dst = s.substring(c + 1); |
| if (isWildcard(src) && isWildcard(dst)) { |
| // Both contain wildcard |
| wildcard = true; |
| } else if (isWildcard(src) || isWildcard(dst)) { |
| wildcard = true; |
| if (mode == WildcardMode.REQUIRE_MATCH) |
| throw new IllegalArgumentException(MessageFormat |
| .format(JGitText.get().invalidWildcards, spec)); |
| } |
| srcName = checkValid(src); |
| dstName = checkValid(dst); |
| } else { |
| if (isWildcard(s)) { |
| if (mode == WildcardMode.REQUIRE_MATCH) { |
| throw new IllegalArgumentException(MessageFormat |
| .format(JGitText.get().invalidWildcards, spec)); |
| } |
| wildcard = true; |
| } |
| srcName = checkValid(s); |
| } |
| } |
| |
| /** |
| * Parse a ref specification for use during transport operations. |
| * <p> |
| * Specifications are typically one of the following forms: |
| * <ul> |
| * <li><code>refs/heads/master</code></li> |
| * <li><code>refs/heads/master:refs/remotes/origin/master</code></li> |
| * <li><code>refs/heads/*:refs/remotes/origin/*</code></li> |
| * <li><code>+refs/heads/master</code></li> |
| * <li><code>+refs/heads/master:refs/remotes/origin/master</code></li> |
| * <li><code>+refs/heads/*:refs/remotes/origin/*</code></li> |
| * <li><code>+refs/pull/*/head:refs/remotes/origin/pr/*</code></li> |
| * <li><code>:refs/heads/master</code></li> |
| * </ul> |
| * |
| * @param spec |
| * string describing the specification. |
| * @throws java.lang.IllegalArgumentException |
| * the specification is invalid. |
| */ |
| public RefSpec(String spec) { |
| this(spec, WildcardMode.REQUIRE_MATCH); |
| } |
| |
| private RefSpec(RefSpec p) { |
| force = p.isForceUpdate(); |
| wildcard = p.isWildcard(); |
| srcName = p.getSource(); |
| dstName = p.getDestination(); |
| allowMismatchedWildcards = p.allowMismatchedWildcards; |
| } |
| |
| /** |
| * Check if this specification wants to forcefully update the destination. |
| * |
| * @return true if this specification asks for updates without merge tests. |
| */ |
| public boolean isForceUpdate() { |
| return force; |
| } |
| |
| /** |
| * Create a new RefSpec with a different force update setting. |
| * |
| * @param forceUpdate |
| * new value for force update in the returned instance. |
| * @return a new RefSpec with force update as specified. |
| */ |
| public RefSpec setForceUpdate(boolean forceUpdate) { |
| final RefSpec r = new RefSpec(this); |
| r.force = forceUpdate; |
| return r; |
| } |
| |
| /** |
| * Check if this specification is actually a wildcard pattern. |
| * <p> |
| * If this is a wildcard pattern then the source and destination names |
| * returned by {@link #getSource()} and {@link #getDestination()} will not |
| * be actual ref names, but instead will be patterns. |
| * |
| * @return true if this specification could match more than one ref. |
| */ |
| public boolean isWildcard() { |
| return wildcard; |
| } |
| |
| /** |
| * Get the source ref description. |
| * <p> |
| * During a fetch this is the name of the ref on the remote repository we |
| * are fetching from. During a push this is the name of the ref on the local |
| * repository we are pushing out from. |
| * |
| * @return name (or wildcard pattern) to match the source ref. |
| */ |
| public String getSource() { |
| return srcName; |
| } |
| |
| /** |
| * Create a new RefSpec with a different source name setting. |
| * |
| * @param source |
| * new value for source in the returned instance. |
| * @return a new RefSpec with source as specified. |
| * @throws java.lang.IllegalStateException |
| * There is already a destination configured, and the wildcard |
| * status of the existing destination disagrees with the |
| * wildcard status of the new source. |
| */ |
| public RefSpec setSource(String source) { |
| final RefSpec r = new RefSpec(this); |
| r.srcName = checkValid(source); |
| if (isWildcard(r.srcName) && r.dstName == null) |
| throw new IllegalStateException(JGitText.get().destinationIsNotAWildcard); |
| if (isWildcard(r.srcName) != isWildcard(r.dstName)) |
| throw new IllegalStateException(JGitText.get().sourceDestinationMustMatch); |
| return r; |
| } |
| |
| /** |
| * Get the destination ref description. |
| * <p> |
| * During a fetch this is the local tracking branch that will be updated |
| * with the new ObjectId after fetching is complete. During a push this is |
| * the remote ref that will be updated by the remote's receive-pack process. |
| * <p> |
| * If null during a fetch no tracking branch should be updated and the |
| * ObjectId should be stored transiently in order to prepare a merge. |
| * <p> |
| * If null during a push, use {@link #getSource()} instead. |
| * |
| * @return name (or wildcard) pattern to match the destination ref. |
| */ |
| public String getDestination() { |
| return dstName; |
| } |
| |
| /** |
| * Create a new RefSpec with a different destination name setting. |
| * |
| * @param destination |
| * new value for destination in the returned instance. |
| * @return a new RefSpec with destination as specified. |
| * @throws java.lang.IllegalStateException |
| * There is already a source configured, and the wildcard status |
| * of the existing source disagrees with the wildcard status of |
| * the new destination. |
| */ |
| public RefSpec setDestination(String destination) { |
| final RefSpec r = new RefSpec(this); |
| r.dstName = checkValid(destination); |
| if (isWildcard(r.dstName) && r.srcName == null) |
| throw new IllegalStateException(JGitText.get().sourceIsNotAWildcard); |
| if (isWildcard(r.srcName) != isWildcard(r.dstName)) |
| throw new IllegalStateException(JGitText.get().sourceDestinationMustMatch); |
| return r; |
| } |
| |
| /** |
| * Create a new RefSpec with a different source/destination name setting. |
| * |
| * @param source |
| * new value for source in the returned instance. |
| * @param destination |
| * new value for destination in the returned instance. |
| * @return a new RefSpec with destination as specified. |
| * @throws java.lang.IllegalArgumentException |
| * The wildcard status of the new source disagrees with the |
| * wildcard status of the new destination. |
| */ |
| public RefSpec setSourceDestination(final String source, |
| final String destination) { |
| if (isWildcard(source) != isWildcard(destination)) |
| throw new IllegalStateException(JGitText.get().sourceDestinationMustMatch); |
| final RefSpec r = new RefSpec(this); |
| r.wildcard = isWildcard(source); |
| r.srcName = source; |
| r.dstName = destination; |
| return r; |
| } |
| |
| /** |
| * Does this specification's source description match the ref name? |
| * |
| * @param r |
| * ref name that should be tested. |
| * @return true if the names match; false otherwise. |
| */ |
| public boolean matchSource(String r) { |
| return match(r, getSource()); |
| } |
| |
| /** |
| * Does this specification's source description match the ref? |
| * |
| * @param r |
| * ref whose name should be tested. |
| * @return true if the names match; false otherwise. |
| */ |
| public boolean matchSource(Ref r) { |
| return match(r.getName(), getSource()); |
| } |
| |
| /** |
| * Does this specification's destination description match the ref name? |
| * |
| * @param r |
| * ref name that should be tested. |
| * @return true if the names match; false otherwise. |
| */ |
| public boolean matchDestination(String r) { |
| return match(r, getDestination()); |
| } |
| |
| /** |
| * Does this specification's destination description match the ref? |
| * |
| * @param r |
| * ref whose name should be tested. |
| * @return true if the names match; false otherwise. |
| */ |
| public boolean matchDestination(Ref r) { |
| return match(r.getName(), getDestination()); |
| } |
| |
| /** |
| * Expand this specification to exactly match a ref name. |
| * <p> |
| * Callers must first verify the passed ref name matches this specification, |
| * otherwise expansion results may be unpredictable. |
| * |
| * @param r |
| * a ref name that matched our source specification. Could be a |
| * wildcard also. |
| * @return a new specification expanded from provided ref name. Result |
| * specification is wildcard if and only if provided ref name is |
| * wildcard. |
| * @throws java.lang.IllegalStateException |
| * when the RefSpec was constructed with wildcard mode that |
| * doesn't require matching wildcards. |
| */ |
| public RefSpec expandFromSource(String r) { |
| if (allowMismatchedWildcards != WildcardMode.REQUIRE_MATCH) { |
| throw new IllegalStateException( |
| JGitText.get().invalidExpandWildcard); |
| } |
| return isWildcard() ? new RefSpec(this).expandFromSourceImp(r) : this; |
| } |
| |
| private RefSpec expandFromSourceImp(String name) { |
| final String psrc = srcName, pdst = dstName; |
| wildcard = false; |
| srcName = name; |
| dstName = expandWildcard(name, psrc, pdst); |
| return this; |
| } |
| |
| /** |
| * Expand this specification to exactly match a ref. |
| * <p> |
| * Callers must first verify the passed ref matches this specification, |
| * otherwise expansion results may be unpredictable. |
| * |
| * @param r |
| * a ref that matched our source specification. Could be a |
| * wildcard also. |
| * @return a new specification expanded from provided ref name. Result |
| * specification is wildcard if and only if provided ref name is |
| * wildcard. |
| * @throws java.lang.IllegalStateException |
| * when the RefSpec was constructed with wildcard mode that |
| * doesn't require matching wildcards. |
| */ |
| public RefSpec expandFromSource(Ref r) { |
| return expandFromSource(r.getName()); |
| } |
| |
| /** |
| * Expand this specification to exactly match a ref name. |
| * <p> |
| * Callers must first verify the passed ref name matches this specification, |
| * otherwise expansion results may be unpredictable. |
| * |
| * @param r |
| * a ref name that matched our destination specification. Could |
| * be a wildcard also. |
| * @return a new specification expanded from provided ref name. Result |
| * specification is wildcard if and only if provided ref name is |
| * wildcard. |
| * @throws java.lang.IllegalStateException |
| * when the RefSpec was constructed with wildcard mode that |
| * doesn't require matching wildcards. |
| */ |
| public RefSpec expandFromDestination(String r) { |
| if (allowMismatchedWildcards != WildcardMode.REQUIRE_MATCH) { |
| throw new IllegalStateException( |
| JGitText.get().invalidExpandWildcard); |
| } |
| return isWildcard() ? new RefSpec(this).expandFromDstImp(r) : this; |
| } |
| |
| private RefSpec expandFromDstImp(String name) { |
| final String psrc = srcName, pdst = dstName; |
| wildcard = false; |
| srcName = expandWildcard(name, pdst, psrc); |
| dstName = name; |
| return this; |
| } |
| |
| /** |
| * Expand this specification to exactly match a ref. |
| * <p> |
| * Callers must first verify the passed ref matches this specification, |
| * otherwise expansion results may be unpredictable. |
| * |
| * @param r |
| * a ref that matched our destination specification. |
| * @return a new specification expanded from provided ref name. Result |
| * specification is wildcard if and only if provided ref name is |
| * wildcard. |
| * @throws java.lang.IllegalStateException |
| * when the RefSpec was constructed with wildcard mode that |
| * doesn't require matching wildcards. |
| */ |
| public RefSpec expandFromDestination(Ref r) { |
| return expandFromDestination(r.getName()); |
| } |
| |
| private boolean match(String name, String s) { |
| if (s == null) |
| return false; |
| if (isWildcard(s)) { |
| int wildcardIndex = s.indexOf('*'); |
| String prefix = s.substring(0, wildcardIndex); |
| String suffix = s.substring(wildcardIndex + 1); |
| return name.length() > prefix.length() + suffix.length() |
| && name.startsWith(prefix) && name.endsWith(suffix); |
| } |
| return name.equals(s); |
| } |
| |
| private static String expandWildcard(String name, String patternA, |
| String patternB) { |
| int a = patternA.indexOf('*'); |
| int trailingA = patternA.length() - (a + 1); |
| int b = patternB.indexOf('*'); |
| String match = name.substring(a, name.length() - trailingA); |
| return patternB.substring(0, b) + match + patternB.substring(b + 1); |
| } |
| |
| private static String checkValid(String spec) { |
| if (spec != null && !isValid(spec)) |
| throw new IllegalArgumentException(MessageFormat.format( |
| JGitText.get().invalidRefSpec, spec)); |
| return spec; |
| } |
| |
| private static boolean isValid(String s) { |
| if (s.startsWith("/")) //$NON-NLS-1$ |
| return false; |
| if (s.contains("//")) //$NON-NLS-1$ |
| return false; |
| if (s.endsWith("/")) //$NON-NLS-1$ |
| return false; |
| int i = s.indexOf('*'); |
| if (i != -1) { |
| if (s.indexOf('*', i + 1) > i) |
| return false; |
| } |
| return true; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public int hashCode() { |
| int hc = 0; |
| if (getSource() != null) |
| hc = hc * 31 + getSource().hashCode(); |
| if (getDestination() != null) |
| hc = hc * 31 + getDestination().hashCode(); |
| return hc; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public boolean equals(Object obj) { |
| if (!(obj instanceof RefSpec)) |
| return false; |
| final RefSpec b = (RefSpec) obj; |
| if (isForceUpdate() != b.isForceUpdate()) |
| return false; |
| if (isWildcard() != b.isWildcard()) |
| return false; |
| if (!eq(getSource(), b.getSource())) |
| return false; |
| if (!eq(getDestination(), b.getDestination())) |
| return false; |
| return true; |
| } |
| |
| private static boolean eq(String a, String b) { |
| if (a == b) |
| return true; |
| if (a == null || b == null) |
| return false; |
| return a.equals(b); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public String toString() { |
| final StringBuilder r = new StringBuilder(); |
| if (isForceUpdate()) |
| r.append('+'); |
| if (getSource() != null) |
| r.append(getSource()); |
| if (getDestination() != null) { |
| r.append(':'); |
| r.append(getDestination()); |
| } |
| return r.toString(); |
| } |
| } |
