[Fix #991] Changing URLPatternMatcher implementation

fjtirado · fjtirado · commit ab0791920fd0 · 2025-02-17T18:33:33.000+01:00
diff --git a/client/runtime/src/main/java/io/quarkiverse/openapi/generator/providers/UrlPatternMatcher.java b/client/runtime/src/main/java/io/quarkiverse/openapi/generator/providers/UrlPatternMatcher.java
@@ -1,102 +1,45 @@
 /*
   Original Copyright Headers
-  This file has been modified, but copied from
-  https://github.com/RestExpress/RestExpress/blob/master/core/src/main/java/org/restexpress/url/UrlPattern.java
+  This file include excerpt copied from
+  https://github.com/wilkincheung/URI-Template-Pattern-Matcher/blob/master/src/main/java/com/prodigi/service/UriTemplateValidator.java
  */
 /**
- * Copyright 2010, Strategic Gains, Inc.
- * <p>
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.quarkiverse.openapi.generator.providers;
-
-import java.util.regex.Pattern;
-
-/**
- * PathPatternMatcher leverages Regex Pattern to represent a parameterized URL. Parameters within the URL are
- * denoted by curly braces '{}' with the parameter name contained within (e.g. '{userid}').
- * <p>
- * <p/>
- * Parameter names must be formed of word characters (e.g. A-Z, a-z, 0-9, '_').
- * <p/>
- * An optional format parameter following a dot ('.') may be added to the end. While it could be named any valid parameter name,
- * RestExpress offers special handling (e.g. within the Request, etc.) if it's named 'format'.
- * <p/>
- * Note that the format specifier allows only word characters and percent-encoded characters.
- * <p>
- * <p/>
- * URL Pattern examples:
- * <ul>
- * <li>/api/search.{format}</li>
- * <li>/api/search/users/{userid}.{format}</li>
- * <li>/api/{version}/search/users/{userid}</li>
- * </ul>
- * <p>
- * RestExpress parses URI paths which is described in the URI Generic Syntax IETF RFC 3986 specification,
- * section 3.3 (http://tools.ietf.org/html/rfc3986#section-3.3). RestExpress parses paths into segments
- * separated by slashes ("/"), the segments of which are composed of unreserved, percent encoded,
- * sub-delimiters, colon (":") or ampersand ("@"), each of which are defined below (from the spec):
- * <p/>
- * pct-encoded = "%" HEXDIG HEXDIG
- * <p/>
- * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"<br/>
- * reserved = gen-delims / sub-delims<br/>
- * gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"</br>
- * sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "=" *
- * <p/>
- * In other words, RestExpress accepts path segments containing: [A-Z] [a-z] [0-9] % - . _ ~ ! $ & ' ( ) * + , ; = : @
- * <p/>
- * RestExpress also accepts square brackets ('[' and ']'), but this is deprecated and not recommended.
- *
- * @author toddf
- * @see <a href="Uniform Resource Identifier (URI): Generic Syntax">http://www.ietf.org/rfc/rfc3986.txt</a>
- * @since Apr 28, 2010
- */
-public class UrlPatternMatcher {
-    // Finds parameters in the URL pattern string.
-    private static final String URL_PARAM_REGEX = "\\{(\\S*?)\\}";
+The MIT License (MIT)
+Copyright (c) 2015 Wilkin Cheung
 
-    // Replaces parameter names in the URL pattern string to match parameters in URLs.
-    private static final String URL_PARAM_MATCH_REGEX = "\\([%\\\\w-.\\\\~!\\$&'\\\\(\\\\)\\\\*\\\\+,;=:\\\\[\\\\]@]+?\\)";
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-    // Finds the 'format' portion of the URL pattern string.
-    private static final String URL_FORMAT_REGEX = "(?:\\.\\{format\\})$";
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-    // Replaces the format parameter name in the URL pattern string to match the format specifier in URLs. Appended to the end of the regex string
-    // when a URL pattern contains a format parameter.
-    private static final String URL_FORMAT_MATCH_REGEX = "(?:\\\\.\\([\\\\w%]+?\\))?";
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+package io.quarkiverse.openapi.generator.providers;
 
-    // Finds the query string portion within a URL. Appended to the end of the built-up regex string.
-    private static final String URL_QUERY_STRING_REGEX = "(?:\\?.*?)?$";
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
-    /**
-     * The URL pattern describing the URL layout and any parameters.
-     */
-    private final String urlPattern;
+public class UrlPatternMatcher {
 
-    /**
-     * A compiled regex created from the urlPattern, above.
-     */
-    private Pattern compiledUrl;
+    private UriTemplate uriTemplate;
 
-    /**
-     * @param pattern
-     */
     public UrlPatternMatcher(String pattern) {
-        this.urlPattern = pattern;
-        String parsedPattern = this.urlPattern.replaceFirst(URL_FORMAT_REGEX, URL_FORMAT_MATCH_REGEX);
-        parsedPattern = parsedPattern.replaceAll(URL_PARAM_REGEX, URL_PARAM_MATCH_REGEX);
-        this.compiledUrl = Pattern.compile(parsedPattern + URL_QUERY_STRING_REGEX);
+        this.uriTemplate = new UriTemplate(pattern);
     }
 
     /**
@@ -107,6 +50,113 @@ public UrlPatternMatcher(String pattern) {
      * @return true if the given URL matches the underlying pattern. Otherwise false.
      */
     public boolean matches(String url) {
-        return compiledUrl.matcher(url).matches();
+        return uriTemplate.matches(url);
+    }
+
+    private static class UriTemplate {
+
+        // For each pattern {keyName} replaces it with (.*)
+        private static final Pattern LEVEL_ONE_PATTERN = Pattern
+                .compile("\\{([^/]+?)\\}");
+        // Replaces each {keyName} with (.*)
+        private static final String REPLACES_WITH = "(.*)";
+
+        /**
+         * Ordered keyNames
+         */
+        private final List<String> keys;
+
+        /**
+         * Pattern
+         */
+        private final Pattern pattern;
+
+        /**
+         * UriTemplate for internal parsing to regular expression
+         *
+         * @param uriTemplate uriTemplate to be parsed
+         */
+        public UriTemplate(String uriTemplate) {
+
+            StringBuilder patternBuilder = new StringBuilder();
+
+            keys = new ArrayList<String>();
+            Matcher m = LEVEL_ONE_PATTERN.matcher(uriTemplate);
+            int start;
+            int end = 0;
+
+            // In each loop, find next pattern in URI that is "{keyName}"
+            // If found, then add "keyName" to keyNames, and append the substring to
+            // patternBuilder.
+            while (m.find()) {
+
+                // move start pointer to last match
+                start = m.start();
+
+                // Mark the pattern as escaped
+                String escaped = Pattern.quote(uriTemplate.substring(end, start));
+
+                patternBuilder.append(escaped);
+
+                patternBuilder.append(REPLACES_WITH);
+
+                // save the previously matched sequence (that is, keyName)
+                // group(1) means the substring within (.*)
+                keys.add(m.group(1));
+
+                // move end pointer to the end of matched string
+                end = m.end();
+            }
+
+            // Mark the pattern as escaped
+            patternBuilder.append(Pattern.quote(uriTemplate.substring(end,
+                    uriTemplate
+                            .length())));
+            this.pattern = Pattern.compile(patternBuilder.toString());
+
+        }
+
+        /**
+         * Match the given URI to a map of key values. Keys in the returned map are
+         * key names, values are key values, as occurred in the given URI.
+         *
+         * For example:
+         * <code>
+         *   UriTemplate t = new UriTemplate("/human/v1/{typeA}/en-US/{typeB}/id/{typeC}.json");
+         *   t.match("http://api.prodigisoftware.com/human/v1/rec/en-US/movies/id/123.json");
+         * </code>
+         * ...would return: {typeA=rec, typeB=movies, typeC=123}
+         *
+         * If not a match, then returning <code>map</code> will have size 0.
+         *
+         * @param uri to try to match to
+         * @return Map of matching key name (Map key), key value (Map value)
+         */
+        public Map<String, String> match(String uri) {
+            // LinkedHashMap to maintain key insertion order
+            Map<String, String> result = new LinkedHashMap<>(keys.size());
+
+            Matcher matcher = pattern.matcher(uri);
+
+            // find next part in uri that matches the pattern
+            if (matcher.find()) {
+                for (int i = 0; i < matcher.groupCount(); i++) {
+                    String name = keys.get(i);
+                    String value = matcher.group(i + 1);
+                    result.put(name, value);
+                }
+            }
+            return result;
+        }
+
+        /**
+         * See if uri matches the pattern.
+         *
+         * @param uri String for matching
+         * @return true if there is one or more matches; false otherwise
+         */
+        public boolean matches(String uri) {
+            return match(uri).size() > 0;
+        }
     }
-}
+}
diff --git a/client/runtime/src/test/java/io/quarkiverse/openapi/generator/providers/UrlPatternMatcherTest.java b/client/runtime/src/test/java/io/quarkiverse/openapi/generator/providers/UrlPatternMatcherTest.java
@@ -16,6 +16,13 @@ void verifyPathsMatch(final String pathPattern, final String requestPath) {
         Assertions.assertTrue(pattern.matches(requestPath));
     }
 
+    @ParameterizedTest
+    @MethodSource("providePathsThatNotMatch")
+    void verifyPathsNotMatch(final String pathPattern, final String requestPath) {
+        UrlPatternMatcher pattern = new UrlPatternMatcher(pathPattern);
+        Assertions.assertFalse(pattern.matches(requestPath));
+    }
+
     private static Stream<Arguments> providePathsThatMatch() {
         return Stream.of(
                 Arguments.of("/pets/{id}", "/pets/1"),
@@ -32,7 +39,14 @@ private static Stream<Arguments> providePathsThatMatch() {
                 Arguments.of("/{id}/{foo}/{id2}", "/1/2/3?q=1&q2=2"),
                 Arguments.of("/{id}/{foo}/{id2}", "/1/2/3"),
                 Arguments.of("/v2/pets/{id}", "/v2/pets/1"),
-                Arguments.of("/pets/{pet-id}/types/{type-id}", "/pets/1/types/2"));
+                Arguments.of("/pets/{pet-id}/types/{type-id}", "/pets/1/types/2"),
+                Arguments.of("/repos/{ref}", "/repos/prefixed/cool.sw"));
+    }
+
+    private static Stream<Arguments> providePathsThatNotMatch() {
+        return Stream.of(
+                Arguments.of("/pets/{id}", "/pes/1"),
+                Arguments.of("/{id}/pepe", "/1/2/pep"));
     }
 
 }
