private static boolean patternMatchesHost(String pattern, String name) { if (pattern.indexOf('*') >= 0 || pattern.indexOf('?') >= 0) { final FileNameMatcher fn; try { fn = new FileNameMatcher(pattern, null); } catch (InvalidPatternException e) { return false; } fn.append(name); return fn.isMatch(); } else { // Not a pattern but a full host name return pattern.equals(name); } }
/** * Constructor for FileNameMatcher * * @param patternString * must contain a pattern which fnmatch would accept. * @param invalidWildgetCharacter * if this parameter isn't null then this character will not * match at wildcards(* and ? are wildcards). * @throws org.eclipse.jgit.errors.InvalidPatternException * if the patternString contains a invalid fnmatch pattern. */ public FileNameMatcher(final String patternString, final Character invalidWildgetCharacter) throws InvalidPatternException { this(createHeadsStartValues(patternString, invalidWildgetCharacter)); }
private static List<AbstractHead> parseHeads(final String pattern, final Character invalidWildgetCharacter) throws InvalidPatternException { int currentIndex = 0; List<AbstractHead> heads = new ArrayList<>(); while (currentIndex < pattern.length()) { final int groupStart = indexOfUnescaped(pattern, '[', currentIndex); if (groupStart == -1) { final String patternPart = pattern.substring(currentIndex); heads.addAll(createSimpleHeads(patternPart, invalidWildgetCharacter)); currentIndex = pattern.length(); } else { final String patternPart = pattern.substring(currentIndex, groupStart); heads.addAll(createSimpleHeads(patternPart, invalidWildgetCharacter)); final int groupEnd = findGroupEnd(groupStart, pattern); final String groupPart = pattern.substring(groupStart + 1, groupEnd); heads.add(new GroupHead(groupPart, pattern)); currentIndex = groupEnd + 1; } } return heads; }
private void removeFromList(Set<String> current, String key, String patterns) { for (String toRemove : patterns.split("\\s*,\\s*")) { //$NON-NLS-1$ if (toRemove.indexOf('*') < 0 && toRemove.indexOf('?') < 0) { current.remove(toRemove); continue; } try { FileNameMatcher matcher = new FileNameMatcher(toRemove, null); for (Iterator<String> i = current.iterator(); i.hasNext();) { matcher.reset(); matcher.append(i.next()); if (matcher.isMatch()) { i.remove(); } } } catch (InvalidPatternException e) { log.warn(format(SshdText.get().configInvalidPattern, key, toRemove)); } } }
/** * Create a {@link org.eclipse.jgit.fnmatch.FileNameMatcher} instance which * uses the same pattern like this matcher, but has the current state of * this matcher as reset and start point * * @return a {@link org.eclipse.jgit.fnmatch.FileNameMatcher} instance which * uses the same pattern like this matcher, but has the current * state of this matcher as reset and start point. */ public FileNameMatcher createMatcherForSuffix() { final List<Head> copyOfHeads = new ArrayList<>(heads.size()); copyOfHeads.addAll(heads); return new FileNameMatcher(copyOfHeads); }
/** * Append to the string which is matched against the patterns of this class * * @param stringToMatch * extends the string which is matched against the patterns of * this class. */ public void append(String stringToMatch) { for (int i = 0; i < stringToMatch.length(); i++) { final char c = stringToMatch.charAt(i); if (!extendStringToMatchByOneCharacter(c)) break; } }
private static List<Head> createHeadsStartValues( final String patternString, final Character invalidWildgetCharacter) throws InvalidPatternException { final List<AbstractHead> allHeads = parseHeads(patternString, invalidWildgetCharacter); List<Head> nextHeadsSuggestion = new ArrayList<>(2); nextHeadsSuggestion.add(LastHead.INSTANCE); for (int i = allHeads.size() - 1; i >= 0; i--) { final AbstractHead head = allHeads.get(i); // explanation: // a and * of the pattern "a*b" // need *b as newHeads // that's why * extends the list for it self and it's left neighbor. if (head.isStar()) { nextHeadsSuggestion.add(head); head.setNewHeads(nextHeadsSuggestion); } else { head.setNewHeads(nextHeadsSuggestion); nextHeadsSuggestion = new ArrayList<>(2); nextHeadsSuggestion.add(head); } } return nextHeadsSuggestion; }
switch (c) { case '*': { final AbstractHead head = createWildCardHead( invalidWildgetCharacter, true); heads.add(head); final AbstractHead head = createWildCardHead( invalidWildgetCharacter, false); heads.add(head);
while (groupEnd == -1) { final int possibleGroupEnd = indexOfUnescaped(pattern, ']', firstValidEndBracketIndex); if (possibleGroupEnd == -1)
/** {@inheritDoc} */ @Override public Set<String> getTagNames(String tagPattern) throws GitException { if (tagPattern == null) tagPattern = "*"; Set<String> tags = new HashSet<>(); try (Repository repo = getRepository()) { FileNameMatcher matcher = new FileNameMatcher(tagPattern, null); Map<String, Ref> tagList = repo.getTags(); for (String name : tagList.keySet()) { matcher.reset(); matcher.append(name); if (matcher.isMatch()) tags.add(name); } } catch (InvalidPatternException e) { throw new GitException(e); } return tags; }
/** * * @return a {@link FileNameMatcher} instance which uses the same pattern * like this matcher, but has the current state of this matcher as * reset and start point. */ public FileNameMatcher createMatcherForSuffix() { final List<Head> copyOfHeads = new ArrayList<Head>(heads.size()); copyOfHeads.addAll(heads); return new FileNameMatcher(copyOfHeads); }
/** * * @param stringToMatch * extends the string which is matched against the patterns of * this class. */ public void append(final String stringToMatch) { for (int i = 0; i < stringToMatch.length(); i++) { final char c = stringToMatch.charAt(i); if (!extendStringToMatchByOneCharacter(c)) break; } }
private static List<Head> createHeadsStartValues( final String patternString, final Character invalidWildgetCharacter) throws InvalidPatternException { final List<AbstractHead> allHeads = parseHeads(patternString, invalidWildgetCharacter); List<Head> nextHeadsSuggestion = new ArrayList<Head>(2); nextHeadsSuggestion.add(LastHead.INSTANCE); for (int i = allHeads.size() - 1; i >= 0; i--) { final AbstractHead head = allHeads.get(i); // explanation: // a and * of the pattern "a*b" // need *b as newHeads // that's why * extends the list for it self and it's left neighbor. if (head.isStar()) { nextHeadsSuggestion.add(head); head.setNewHeads(nextHeadsSuggestion); } else { head.setNewHeads(nextHeadsSuggestion); nextHeadsSuggestion = new ArrayList<Head>(2); nextHeadsSuggestion.add(head); } } return nextHeadsSuggestion; }
switch (c) { case '*': { final AbstractHead head = createWildCardHead( invalidWildgetCharacter, true); heads.add(head); final AbstractHead head = createWildCardHead( invalidWildgetCharacter, false); heads.add(head);
while (groupEnd == -1) { final int possibleGroupEnd = indexOfUnescaped(pattern, ']', firstValidEndBracketIndex); if (possibleGroupEnd == -1)
/** {@inheritDoc} */ @Override public Set<String> getRemoteTagNames(String tagPattern) throws GitException { /* BUG: Lists local tag names, not remote tag names */ if (tagPattern == null) tagPattern = "*"; try (Repository repo = getRepository()) { Set<String> tags = new HashSet<>(); FileNameMatcher matcher = new FileNameMatcher(tagPattern, '/'); List<Ref> refList = repo.getRefDatabase().getRefsByPrefix(R_TAGS); for (Ref ref : refList) { String name = ref.getName().substring(R_TAGS.length()); matcher.reset(); matcher.append(name); if (matcher.isMatch()) tags.add(name); } return tags; } catch (IOException | InvalidPatternException e) { throw new GitException(e); } }
private static boolean isHostMatch(final String pattern, final String name) { final FileNameMatcher fn; try { fn = new FileNameMatcher(pattern, null); } catch (InvalidPatternException e) { return false; } fn.append(name); return fn.isMatch(); }
private static List<AbstractHead> parseHeads(final String pattern, final Character invalidWildgetCharacter) throws InvalidPatternException { int currentIndex = 0; List<AbstractHead> heads = new ArrayList<AbstractHead>(); while (currentIndex < pattern.length()) { final int groupStart = indexOfUnescaped(pattern, '[', currentIndex); if (groupStart == -1) { final String patternPart = pattern.substring(currentIndex); heads.addAll(createSimpleHeads(patternPart, invalidWildgetCharacter)); currentIndex = pattern.length(); } else { final String patternPart = pattern.substring(currentIndex, groupStart); heads.addAll(createSimpleHeads(patternPart, invalidWildgetCharacter)); final int groupEnd = findGroupEnd(groupStart, pattern); final String groupPart = pattern.substring(groupStart + 1, groupEnd); heads.add(new GroupHead(groupPart, pattern)); currentIndex = groupEnd + 1; } } return heads; }
/** * Create a {@link org.eclipse.jgit.fnmatch.FileNameMatcher} instance which * uses the same pattern like this matcher, but has the current state of * this matcher as reset and start point * * @return a {@link org.eclipse.jgit.fnmatch.FileNameMatcher} instance which * uses the same pattern like this matcher, but has the current * state of this matcher as reset and start point. */ public FileNameMatcher createMatcherForSuffix() { final List<Head> copyOfHeads = new ArrayList<>(heads.size()); copyOfHeads.addAll(heads); return new FileNameMatcher(copyOfHeads); }
/** * Append to the string which is matched against the patterns of this class * * @param stringToMatch * extends the string which is matched against the patterns of * this class. */ public void append(String stringToMatch) { for (int i = 0; i < stringToMatch.length(); i++) { final char c = stringToMatch.charAt(i); if (!extendStringToMatchByOneCharacter(c)) break; } }