/** * Sets one or more {@code glob(7)} patterns that tags must match to be * considered. If multiple patterns are provided, tags only need match one * of them. * * @param patterns * the {@code glob(7)} pattern or patterns * @return {@code this} * @throws org.eclipse.jgit.errors.InvalidPatternException * if the pattern passed in was invalid. * @see <a href= * "https://www.kernel.org/pub/software/scm/git/docs/git-describe.html" * >Git documentation about describe</a> * @since 4.9 */ public DescribeCommand setMatch(String... patterns) throws InvalidPatternException { for (String p : patterns) { matchers.add(PathMatcher.createPathMatcher(p, null, false)); } return this; }
/** * Create path matcher * * @param pattern * a pattern * @param pathSeparator * if this parameter isn't null then this character will not * match at wildcards(* and ? are wildcards). * @param dirOnly * a boolean. * @return never null * @throws org.eclipse.jgit.errors.InvalidPatternException */ public static IMatcher createPathMatcher(String pattern, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { pattern = trim(pattern); char slash = Strings.getPathSeparator(pathSeparator); // ignore possible leading and trailing slash int slashIdx = pattern.indexOf(slash, 1); if (slashIdx > 0 && slashIdx < pattern.length() - 1) return new PathMatcher(pattern, pathSeparator, dirOnly); return createNameMatcher0(pattern, pathSeparator, dirOnly, true); }
private PathMatcher(String pattern, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { super(pattern, dirOnly); slash = getPathSeparator(pathSeparator); beginning = pattern.indexOf(slash) == 0; if (isSimplePathWithSegments(pattern)) matchers = null; else matchers = createMatchers(split(pattern, slash), pathSeparator, dirOnly); }
/** {@inheritDoc} */ @Override public boolean matches(String path, boolean assumeDirectory, boolean pathMatch) { if (matchers == null) { return simpleMatch(path, assumeDirectory, pathMatch); } return iterate(path, 0, path.length(), assumeDirectory, pathMatch); }
private static List<IMatcher> createMatchers(List<String> segments, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { List<IMatcher> matchers = new ArrayList<>(segments.size()); for (int i = 0; i < segments.size(); i++) { String segment = segments.get(i); IMatcher matcher = createNameMatcher0(segment, pathSeparator, dirOnly, i == segments.size() - 1); if (i > 0) { final IMatcher last = matchers.get(matchers.size() - 1); if (isWild(matcher) && isWild(last)) // collapse wildmatchers **/** is same as **, but preserve // dirOnly flag (i.e. always use the last wildmatcher) matchers.remove(matchers.size() - 1); } matchers.add(matcher); } return matchers; }
if (right == -1) { if (left < endExcl) { match = matches(matcher, path, left, endExcl, assumeDirectory, pathMatch); } else { // a/** should not match a/ or a match = match && !isWild(matchers.get(matcher)); && isWild(matchers.get(matcher))) { match = matches(matcher, path, left, endExcl, assumeDirectory, pathMatch); } else if (dirOnly && !assumeDirectory) { match = matches(matcher, path, left, right, assumeDirectory, pathMatch); } else { boolean wasWild = isWild(matchers.get(matcher)); if (wasWild) { lastWildmatch = matcher;
static private List<IMatcher> createMatchers(List<String> segments, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { List<IMatcher> matchers = new ArrayList<IMatcher>(segments.size()); for (int i = 0; i < segments.size(); i++) { String segment = segments.get(i); IMatcher matcher = createNameMatcher0(segment, pathSeparator, dirOnly); if (matcher == WILD && i > 0 && matchers.get(matchers.size() - 1) == WILD) // collapse wildmatchers **/** is same as ** continue; matchers.add(matcher); } return matchers; }
public boolean matches(String path, boolean assumeDirectory) { if (matchers == null) return simpleMatch(path, assumeDirectory); return iterate(path, 0, path.length(), assumeDirectory); }
private static List<IMatcher> createMatchers(List<String> segments, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { List<IMatcher> matchers = new ArrayList<>(segments.size()); for (int i = 0; i < segments.size(); i++) { String segment = segments.get(i); IMatcher matcher = createNameMatcher0(segment, pathSeparator, dirOnly, i == segments.size() - 1); if (i > 0) { final IMatcher last = matchers.get(matchers.size() - 1); if (isWild(matcher) && isWild(last)) // collapse wildmatchers **/** is same as **, but preserve // dirOnly flag (i.e. always use the last wildmatcher) matchers.remove(matchers.size() - 1); } matchers.add(matcher); } return matchers; }
if (right == -1) { if (left < endExcl) { match = matches(matcher, path, left, endExcl, assumeDirectory, pathMatch); } else { // a/** should not match a/ or a match = match && !isWild(matchers.get(matcher)); && isWild(matchers.get(matcher))) { match = matches(matcher, path, left, endExcl, assumeDirectory, pathMatch); } else if (dirOnly && !assumeDirectory) { match = matches(matcher, path, left, right, assumeDirectory, pathMatch); } else { boolean wasWild = isWild(matchers.get(matcher)); if (wasWild) { lastWildmatch = matcher;
/** * Create path matcher * * @param pattern a pattern * @param pathSeparator if this parameter isn't null then this character will not * match at wildcards(* and ? are wildcards). * @param dirOnly a boolean. * @return never null * @throws org.eclipse.jgit.errors.InvalidPatternException */ public static IMatcher createPathMatcher(String pattern, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { pattern = trim(pattern); char slash = Strings.getPathSeparator(pathSeparator); // ignore possible leading and trailing slash int slashIdx = pattern.indexOf(slash, 1); if (slashIdx > 0 && slashIdx < pattern.length() - 1) return new PathMatcher(pattern, pathSeparator, dirOnly); return createNameMatcher0(pattern, pathSeparator, dirOnly, true); }
candidateMatcher = PathMatcher.createPathMatcher(pattern, Character.valueOf(FastIgnoreRule.PATH_SEPARATOR), dirOnly); } catch (InvalidPatternException e) {
private PathMatcher(String pattern, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { super(pattern, dirOnly); slash = getPathSeparator(pathSeparator); beginning = pattern.indexOf(slash) == 0; if (isSimplePathWithSegments(pattern)) matchers = null; else matchers = createMatchers(split(pattern, slash), pathSeparator, dirOnly); }
/** * {@inheritDoc} */ @Override public boolean matches(String path, boolean assumeDirectory, boolean pathMatch) { if (matchers == null) { return simpleMatch(path, assumeDirectory, pathMatch); } return iterate(path, 0, path.length(), assumeDirectory, pathMatch); }
private static List<IMatcher> createMatchers(List<String> segments, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { List<IMatcher> matchers = new ArrayList<>(segments.size()); for (int i = 0; i < segments.size(); i++) { String segment = segments.get(i); IMatcher matcher = createNameMatcher0(segment, pathSeparator, dirOnly, i == segments.size() - 1); if (i > 0) { final IMatcher last = matchers.get(matchers.size() - 1); if (isWild(matcher) && isWild(last)) // collapse wildmatchers **/** is same as **, but preserve // dirOnly flag (i.e. always use the last wildmatcher) matchers.remove(matchers.size() - 1); } matchers.add(matcher); } return matchers; }
if (right == -1) { if (left < endExcl) { match = matches(matcher, path, left, endExcl, assumeDirectory, pathMatch); } else { // a/** should not match a/ or a match = match && !isWild(matchers.get(matcher)); && isWild(matchers.get(matcher))) { match = matches(matcher, path, left, endExcl, assumeDirectory, pathMatch); } else if (dirOnly && !assumeDirectory) { match = matches(matcher, path, left, right, assumeDirectory, pathMatch); } else { boolean wasWild = isWild(matchers.get(matcher)); if (wasWild) { lastWildmatch = matcher;
/** * * @param pattern * @param pathSeparator * if this parameter isn't null then this character will not * match at wildcards(* and ? are wildcards). * @param dirOnly * @return never null * @throws InvalidPatternException */ public static IMatcher createPathMatcher(String pattern, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { pattern = trim(pattern); char slash = Strings.getPathSeparator(pathSeparator); // ignore possible leading and trailing slash int slashIdx = pattern.indexOf(slash, 1); if (slashIdx > 0 && slashIdx < pattern.length() - 1) return new PathMatcher(pattern, pathSeparator, dirOnly); return createNameMatcher0(pattern, pathSeparator, dirOnly); }
m = PathMatcher.createPathMatcher(pattern, Character.valueOf(PATH_SEPARATOR), dirOnly); } catch (InvalidPatternException e) {
PathMatcher(String pattern, Character pathSeparator, boolean dirOnly) throws InvalidPatternException { super(pattern, dirOnly); slash = getPathSeparator(pathSeparator); beginning = pattern.indexOf(slash) == 0; if (isSimplePathWithSegments(pattern)) matchers = null; else matchers = createMatchers(split(pattern, slash), pathSeparator, dirOnly); }