/** * Register a {@link CorsConfiguration} for the specified path pattern. */ public void registerCorsConfiguration(String path, CorsConfiguration config) { this.corsConfigurations.put(this.patternParser.parse(path), config); }
public PathResourceLookupFunction(String pattern, Resource location) { Assert.hasLength(pattern, "'pattern' must not be empty"); Assert.notNull(location, "'location' must not be null"); this.pattern = PATTERN_PARSER.parse(pattern); this.location = location; }
private static List<PathPattern> parse(String[] paths, PathPatternParser parser) { return Arrays .stream(paths) .map(path -> { if (StringUtils.hasText(path) && !path.startsWith("/")) { path = "/" + path; } return parser.parse(path); }) .collect(Collectors.toList()); } }
/** * Return a function that creates new path-matching {@code RequestPredicates} * from pattern Strings using the given {@link PathPatternParser}. * <p>This method can be used to specify a non-default, customized * {@code PathPatternParser} when resolving path patterns. * @param patternParser the parser used to parse patterns given to the returned function * @return a function that resolves a pattern String into a path-matching * {@code RequestPredicates} instance */ public static Function<String, RequestPredicate> pathPredicates(PathPatternParser patternParser) { Assert.notNull(patternParser, "PathPatternParser must not be null"); return pattern -> new PathPatternPredicate(patternParser.parse(pattern)); }
/** * Manually configure resource handler mappings. * <p><strong>Note:</strong> by default resource mappings are auto-detected * from the Spring {@code ApplicationContext}. If this property is used, * auto-detection is turned off. */ public void registerHandlers(Map<String, ResourceWebHandler> handlerMap) { this.handlerMap.clear(); handlerMap.forEach((rawPattern, resourceWebHandler) -> { rawPattern = prependLeadingSlash(rawPattern); PathPattern pattern = this.patternParser.parse(rawPattern); this.handlerMap.put(pattern, resourceWebHandler); }); }
private PatternsRequestCondition createPatternsCondition(String... patterns) { return new PatternsRequestCondition(Arrays .stream(patterns) .map(rawPattern -> this.parser.parse(rawPattern)) .collect(Collectors.toList())); }
private PathPattern parse(String pattern) { PathPatternParser patternParser = new PathPatternParser(); return patternParser.parse(pattern); }
private PathPattern parse(String path) { PathPatternParser pp = new PathPatternParser(); pp.setMatchOptionalTrailingSeparator(true); return pp.parse(path); }
@Test public void extractUriTemplateVariablesRegex() { PathPatternParser pp = new PathPatternParser(); PathPattern p = null; p = pp.parse("{symbolicName:[\\w\\.]+}-{version:[\\w\\.]+}.jar"); PathPattern.PathMatchInfo result = matchAndExtract(p, "com.example-1.0.0.jar"); assertEquals("com.example", result.getUriVariables().get("symbolicName")); assertEquals("1.0.0", result.getUriVariables().get("version")); p = pp.parse("{symbolicName:[\\w\\.]+}-sources-{version:[\\w\\.]+}.jar"); result = matchAndExtract(p, "com.example-sources-1.0.0.jar"); assertEquals("com.example", result.getUriVariables().get("symbolicName")); assertEquals("1.0.0", result.getUriVariables().get("version")); }
@Test public void extractUriTemplateVarsRegexCapturingGroups() { PathPatternParser ppp = new PathPatternParser(); PathPattern pathPattern = ppp.parse("/web/{id:foo(bar)?}_{goo}"); exception.expect(IllegalArgumentException.class); exception.expectMessage(containsString("The number of capturing groups in the pattern")); matchAndExtract(pathPattern,"/web/foobar_goo"); }
@Test public void compare_spr15597() { PathPatternParser parser = new PathPatternParser(); PathPattern p1 = parser.parse("/{foo}"); PathPattern p2 = parser.parse("/{foo}.*"); PathPattern.PathMatchInfo r1 = matchAndExtract(p1, "/file.txt"); PathPattern.PathMatchInfo r2 = matchAndExtract(p2, "/file.txt"); // works fine assertEquals("file.txt", r1.getUriVariables().get("foo")); assertEquals("file", r2.getUriVariables().get("foo")); // This produces 2 (see comments in https://jira.spring.io/browse/SPR-14544 ) // Comparator<String> patternComparator = new AntPathMatcher().getPatternComparator(""); // System.out.println(patternComparator.compare("/{foo}","/{foo}.*")); assertThat(p1.compareTo(p2), Matchers.greaterThan(0)); }
@Test public void equalsAndHashcode() { PathPatternParser caseInsensitiveParser = new PathPatternParser(); caseInsensitiveParser.setCaseSensitive(false); PathPatternParser caseSensitiveParser = new PathPatternParser(); PathPattern pp1 = caseInsensitiveParser.parse("/abc"); PathPattern pp2 = caseInsensitiveParser.parse("/abc"); PathPattern pp3 = caseInsensitiveParser.parse("/def"); assertEquals(pp1, pp2); assertEquals(pp1.hashCode(), pp2.hashCode()); assertNotEquals(pp1, pp3); assertFalse(pp1.equals("abc")); pp1 = caseInsensitiveParser.parse("/abc"); pp2 = caseSensitiveParser.parse("/abc"); assertFalse(pp1.equals(pp2)); assertNotEquals(pp1.hashCode(), pp2.hashCode()); }
@Test public void pathPrefix() throws NoSuchMethodException { this.handlerMapping.setEmbeddedValueResolver(value -> "/${prefix}".equals(value) ? "/api" : value); this.handlerMapping.setPathPrefixes(Collections.singletonMap( "/${prefix}", HandlerTypePredicate.forAnnotation(RestController.class))); Method method = UserController.class.getMethod("getUser"); RequestMappingInfo info = this.handlerMapping.getMappingForMethod(method, UserController.class); assertNotNull(info); assertEquals(Collections.singleton(new PathPatternParser().parse("/api/user/{id}")), info.getPatternsCondition().getPatterns()); }
private void checkNoMatch(String uriTemplate, String path) { PathPatternParser p = new PathPatternParser(); PathPattern pattern = p.parse(uriTemplate); PathContainer PathContainer = toPathContainer(path); assertFalse(pattern.matches(PathContainer)); }
@Override protected String getMatchingMapping(String pattern, ServerWebExchange exchange) { PathContainer lookupPath = exchange.getRequest().getPath().pathWithinApplication(); PathPattern parsedPattern = this.parser.parse(pattern); return (parsedPattern.matches(lookupPath) ? pattern : null); }
private void checkMatches(String uriTemplate, String path) { PathPatternParser parser = new PathPatternParser(); parser.setMatchOptionalTrailingSeparator(true); PathPattern p = parser.parse(uriTemplate); PathContainer pc = toPathContainer(path); assertTrue(p.matches(pc)); }
private void checkExtractPathWithinPattern(String pattern, String path, String expected) { PathPatternParser ppp = new PathPatternParser(); PathPattern pp = ppp.parse(pattern); String s = pp.extractPathWithinPattern(toPathContainer(path)).value(); assertEquals(expected, s); }
@Test // SPR-13286 public void caseInsensitive() { PathPatternParser pp = new PathPatternParser(); pp.setCaseSensitive(false); PathPattern p = pp.parse("/group/{groupName}/members"); assertMatches(p,"/group/sales/members"); assertMatches(p,"/Group/Sales/Members"); assertMatches(p,"/group/Sales/members"); }