/** * Returns true if specified value matches one of specified patterns. * * @since 2.4 */ public static boolean match(WildcardPattern[] patterns, String value) { for (WildcardPattern pattern : patterns) { if (pattern.match(value)) { return true; } } return false; }
boolean matchComponent(@Nullable String path) { return path != null && componentPattern.match(path); }
public boolean matchFile(@Nullable String filePath) { return filePath != null && filePattern.match(filePath); }
private boolean isExcluded(DefaultInputFile file, Collection<WildcardPattern> patterns) { if (patterns.isEmpty()) { return false; } final String path = pathExtractor.apply(file); return patterns .stream() .anyMatch(p -> p.match(path)); }
public boolean matchRule(RuleKey rule) { return rulePattern.match(rule.toString()); }
boolean matchRule(RuleKey rule) { return rulePattern.match(rule.toString()); }
@Override public boolean match(Path absolutePath, Path relativePath, boolean caseSensitiveFileExtension) { String path = PathUtils.sanitize(relativePath.toString()); if (!caseSensitiveFileExtension) { String extension = sanitizeExtension(FilenameUtils.getExtension(path)); if (StringUtils.isNotBlank(extension)) { path = StringUtils.removeEndIgnoreCase(path, extension); path = path + extension; } } return path != null && pattern.match(path); }
@Override public boolean match(Path absolutePath, Path relativePath, boolean caseSensitiveFileExtension) { String path = PathUtils.sanitize(absolutePath.toString()); if (!caseSensitiveFileExtension) { String extension = sanitizeExtension(FilenameUtils.getExtension(path)); if (StringUtils.isNotBlank(extension)) { path = StringUtils.removeEndIgnoreCase(path, extension); path = path + extension; } } return pattern.match(path); }
private boolean hasRuleMatchFor(InputComponent component, FilterableIssue issue) { for (WildcardPattern pattern : rulePatternByComponent.get(component)) { if (pattern.match(issue.ruleKey().toString())) { LOG.debug("Issue {} ignored by exclusion pattern {}", issue, pattern); return true; } } return false; } }
private boolean match(String pattern, String value, String separator) { return new WildcardPattern(pattern, separator).match(value); }
private boolean match(String pattern, String value) { return new WildcardPattern(pattern, "/").match(value); }
@Test public void multiplePatterns() { WildcardPattern[] patterns = WildcardPattern.create(new String[] {"Foo", "Bar"}); assertThat(WildcardPattern.match(patterns, "Foo")).isTrue(); assertThat(WildcardPattern.match(patterns, "Bar")).isTrue(); assertThat(WildcardPattern.match(patterns, "Other")).isFalse(); assertThat(WildcardPattern.create((String[]) null)).isEmpty(); }
private boolean isInclude(DefaultIssue issue, Component file) { boolean atLeastOneRuleMatched = false; boolean atLeastOnePatternFullyMatched = false; IssuePattern matchingPattern = null; for (IssuePattern pattern : inclusionPatterns) { if (pattern.getRulePattern().match(issue.ruleKey().toString())) { atLeastOneRuleMatched = true; String filePath = file.getName(); if (filePath != null && pattern.getComponentPattern().match(filePath)) { atLeastOnePatternFullyMatched = true; matchingPattern = pattern; } } } if (atLeastOneRuleMatched) { if (atLeastOnePatternFullyMatched) { LOG.debug("Issue {} enforced by pattern {}", issue, matchingPattern); } return atLeastOnePatternFullyMatched; } else { return true; } }
@Test public void shouldAcceptIfRulePatternDoesNotMatch() { WildcardPattern pattern = mock(WildcardPattern.class); when(pattern.match(ruleKey.toString())).thenReturn(false); underTest.addRuleExclusionPatternForComponent(component, pattern); assertThat(underTest.accept(issue, chain)).isFalse(); } }
@Test public void shouldRejectIfRulePatternMatches() { WildcardPattern pattern = mock(WildcardPattern.class); when(pattern.match(ruleKey.toString())).thenReturn(true); underTest.addRuleExclusionPatternForComponent(component, pattern); assertThat(underTest.accept(issue, chain)).isFalse(); }
@Override public void visitClass(AsmClass asmClass) { String nameAsmClass = asmClass.getInternalName(); if (WildcardPattern.match(getFromPatterns(), nameAsmClass)) { this.asmClass = asmClass; this.internalNames = Maps.newHashMap(); } else { this.asmClass = null; } }
/** * {@inheritDoc} * * @see Resource#matchFilePattern(String) */ @Override public boolean matchFilePattern(String antPattern) { WildcardPattern matcher = WildcardPattern.create(antPattern, Directory.SEPARATOR); return matcher.match(getKey()); }
@Override public boolean match(InputFile inputFile, boolean caseSensitiveFileExtension) { String path = inputFile.relativePath(); if (!caseSensitiveFileExtension) { String extension = super.sanitizeExtension(FilenameUtils.getExtension(inputFile.file().getName())); if (StringUtils.isNotBlank(extension)) { path = StringUtils.removeEndIgnoreCase(path, extension); path = path + extension; } } return path != null && pattern.match(path); }
@Override public boolean match(InputFile inputFile, boolean caseSensitiveFileExtension) { String path = inputFile.absolutePath(); if (!caseSensitiveFileExtension) { String extension = super.sanitizeExtension(FilenameUtils.getExtension(inputFile.file().getName())); if (StringUtils.isNotBlank(extension)) { path = StringUtils.removeEndIgnoreCase(path, extension); path = path + extension; } } return pattern.match(path); }
@Override public boolean match(Path absolutePath, Path relativePath, boolean caseSensitiveFileExtension) { String path = PathUtils.sanitize(absolutePath.toString()); if (!caseSensitiveFileExtension) { String extension = sanitizeExtension(FilenameUtils.getExtension(path)); if (StringUtils.isNotBlank(extension)) { path = StringUtils.removeEndIgnoreCase(path, extension); path = path + extension; } } return pattern.match(path); }