rpython
diff --git a/‎spring-core/src/main/java/org/springframework/util/AntPathMatcher.java
Lines changed: 91 additions & 3 deletions b/‎spring-core/src/main/java/org/springframework/util/AntPathMatcher.java
Lines changed: 91 additions & 3 deletions
diff --git a/‎spring-core/src/main/java/org/springframework/util/AntPathStringMatcher.java
Lines changed: 0 additions & 120 deletions b/‎spring-core/src/main/java/org/springframework/util/AntPathStringMatcher.java
Lines changed: 0 additions & 120 deletions
@@ -18,6 +18,8 @@
 
 import java.util.Comparator;
 import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.regex.Matcher;
@@ -43,6 +45,7 @@
  * @author Juergen Hoeller
  * @author Rob Harrop
  * @author Arjen Poutsma
+ * @author Rossen Stoyanchev
  * @since 16.07.2003
  */
 public class AntPathMatcher implements PathMatcher {
@@ -55,7 +58,7 @@ public class AntPathMatcher implements PathMatcher {
 	private String pathSeparator = DEFAULT_PATH_SEPARATOR;
 
 	private final Map<String, AntPathStringMatcher> stringMatcherCache =
-			new ConcurrentHashMap<String, AntPathStringMatcher>();
+			new ConcurrentHashMap<String, AntPathStringMatcher>(256);
 
 
 	/** Set the path separator to use for pattern parsing. Default is "/", as in Ant. */
@@ -213,8 +216,9 @@ else if (!fullMatch && "**".equals(pattDirs[pattIdxStart])) {
 	}
 
 	/**
-	 * Tests whether or not a string matches against a pattern. The pattern may contain two special characters:<br> '*'
-	 * means zero or more characters<br> '?' means one and only one character
+	 * Tests whether or not a string matches against a pattern. The pattern may contain two special characters:
+	 * <br>'*' means zero or more characters
+	 * <br>'?' means one and only one character
 	 * @param pattern pattern to match against. Must not be <code>null</code>.
 	 * @param str string which must be matched against the pattern. Must not be <code>null</code>.
 	 * @return <code>true</code> if the string matches against the pattern, or <code>false</code> otherwise.
@@ -462,4 +466,88 @@ private int getPatternLength(String pattern) {
 		}
 	}
 
+
+	/**
+	 * Tests whether or not a string matches against a pattern via a {@link Pattern}.
+	 * <p>The pattern may contain special characters: '*' means zero or more characters; '?' means one and
+	 * only one character; '{' and '}' indicate a URI template pattern. For example <tt>/users/{user}</tt>.
+	 */
+	private static class AntPathStringMatcher {
+
+		private static final Pattern GLOB_PATTERN = Pattern.compile("\\?|\\*|\\{((?:\\{[^/]+?\\}|[^/{}]|\\\\[{}])+?)\\}");
+
+		private static final String DEFAULT_VARIABLE_PATTERN = "(.*)";
+
+		private final Pattern pattern;
+
+		private final List<String> variableNames = new LinkedList<String>();
+
+		public AntPathStringMatcher(String pattern) {
+			StringBuilder patternBuilder = new StringBuilder();
+			Matcher m = GLOB_PATTERN.matcher(pattern);
+			int end = 0;
+			while (m.find()) {
+				patternBuilder.append(quote(pattern, end, m.start()));
+				String match = m.group();
+				if ("?".equals(match)) {
+					patternBuilder.append('.');
+				}
+				else if ("*".equals(match)) {
+					patternBuilder.append(".*");
+				}
+				else if (match.startsWith("{") && match.endsWith("}")) {
+					int colonIdx = match.indexOf(':');
+					if (colonIdx == -1) {
+						patternBuilder.append(DEFAULT_VARIABLE_PATTERN);
+						this.variableNames.add(m.group(1));
+					}
+					else {
+						String variablePattern = match.substring(colonIdx + 1, match.length() - 1);
+						patternBuilder.append('(');
+						patternBuilder.append(variablePattern);
+						patternBuilder.append(')');
+						String variableName = match.substring(1, colonIdx);
+						this.variableNames.add(variableName);
+					}
+				}
+				end = m.end();
+			}
+			patternBuilder.append(quote(pattern, end, pattern.length()));
+			this.pattern = Pattern.compile(patternBuilder.toString());
+		}
+
+		private String quote(String s, int start, int end) {
+			if (start == end) {
+				return "";
+			}
+			return Pattern.quote(s.substring(start, end));
+		}
+
+		/**
+		 * Main entry point.
+		 * @return <code>true</code> if the string matches against the pattern, or <code>false</code> otherwise.
+		 */
+		public boolean matchStrings(String str, Map<String, String> uriTemplateVariables) {
+			Matcher matcher = this.pattern.matcher(str);
+			if (matcher.matches()) {
+				if (uriTemplateVariables != null) {
+					// SPR-8455
+					Assert.isTrue(this.variableNames.size() == matcher.groupCount(),
+							"The number of capturing groups in the pattern segment " + this.pattern +
+							" does not match the number of URI template variables it defines, which can occur if " +
+							" capturing groups are used in a URI template regex. Use non-capturing groups instead.");
+					for (int i = 1; i <= matcher.groupCount(); i++) {
+						String name = this.variableNames.get(i - 1);
+						String value = matcher.group(i);
+						uriTemplateVariables.put(name, value);
+					}
+				}
+				return true;
+			}
+			else {
+				return false;
+			}
+		}
+	}
+
 }