| /* |
| * Copyright (C) 2008, Florian Köberle <florianskarten@web.de> and others |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Distribution License v. 1.0 which is available at |
| * https://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: BSD-3-Clause |
| */ |
| |
| package org.eclipse.jgit.fnmatch; |
| |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.jgit.errors.InvalidPatternException; |
| import org.eclipse.jgit.internal.JGitText; |
| |
| final class GroupHead extends AbstractHead { |
| private final List<CharacterPattern> characterClasses; |
| |
| private static final Pattern REGEX_PATTERN = Pattern |
| .compile("([^-][-][^-]|\\[[.:=].*?[.:=]\\])"); //$NON-NLS-1$ |
| |
| private final boolean inverse; |
| |
| GroupHead(String pattern, String wholePattern) |
| throws InvalidPatternException { |
| super(false); |
| this.characterClasses = new ArrayList<>(); |
| this.inverse = pattern.startsWith("!"); //$NON-NLS-1$ |
| if (inverse) { |
| pattern = pattern.substring(1); |
| } |
| final Matcher matcher = REGEX_PATTERN.matcher(pattern); |
| while (matcher.find()) { |
| final String characterClass = matcher.group(0); |
| if (characterClass.length() == 3 && characterClass.charAt(1) == '-') { |
| final char start = characterClass.charAt(0); |
| final char end = characterClass.charAt(2); |
| characterClasses.add(new CharacterRange(start, end)); |
| } else if (characterClass.equals("[:alnum:]")) { //$NON-NLS-1$ |
| characterClasses.add(LetterPattern.INSTANCE); |
| characterClasses.add(DigitPattern.INSTANCE); |
| } else if (characterClass.equals("[:alpha:]")) { //$NON-NLS-1$ |
| characterClasses.add(LetterPattern.INSTANCE); |
| } else if (characterClass.equals("[:blank:]")) { //$NON-NLS-1$ |
| characterClasses.add(new OneCharacterPattern(' ')); |
| characterClasses.add(new OneCharacterPattern('\t')); |
| } else if (characterClass.equals("[:cntrl:]")) { //$NON-NLS-1$ |
| characterClasses.add(new CharacterRange('\u0000', '\u001F')); |
| characterClasses.add(new OneCharacterPattern('\u007F')); |
| } else if (characterClass.equals("[:digit:]")) { //$NON-NLS-1$ |
| characterClasses.add(DigitPattern.INSTANCE); |
| } else if (characterClass.equals("[:graph:]")) { //$NON-NLS-1$ |
| characterClasses.add(new CharacterRange('\u0021', '\u007E')); |
| characterClasses.add(LetterPattern.INSTANCE); |
| characterClasses.add(DigitPattern.INSTANCE); |
| } else if (characterClass.equals("[:lower:]")) { //$NON-NLS-1$ |
| characterClasses.add(LowerPattern.INSTANCE); |
| } else if (characterClass.equals("[:print:]")) { //$NON-NLS-1$ |
| characterClasses.add(new CharacterRange('\u0020', '\u007E')); |
| characterClasses.add(LetterPattern.INSTANCE); |
| characterClasses.add(DigitPattern.INSTANCE); |
| } else if (characterClass.equals("[:punct:]")) { //$NON-NLS-1$ |
| characterClasses.add(PunctPattern.INSTANCE); |
| } else if (characterClass.equals("[:space:]")) { //$NON-NLS-1$ |
| characterClasses.add(WhitespacePattern.INSTANCE); |
| } else if (characterClass.equals("[:upper:]")) { //$NON-NLS-1$ |
| characterClasses.add(UpperPattern.INSTANCE); |
| } else if (characterClass.equals("[:xdigit:]")) { //$NON-NLS-1$ |
| characterClasses.add(new CharacterRange('0', '9')); |
| characterClasses.add(new CharacterRange('a', 'f')); |
| characterClasses.add(new CharacterRange('A', 'F')); |
| } else if (characterClass.equals("[:word:]")) { //$NON-NLS-1$ |
| characterClasses.add(new OneCharacterPattern('_')); |
| characterClasses.add(LetterPattern.INSTANCE); |
| characterClasses.add(DigitPattern.INSTANCE); |
| } else { |
| final String message = MessageFormat.format( |
| JGitText.get().characterClassIsNotSupported, |
| characterClass); |
| throw new InvalidPatternException(message, wholePattern); |
| } |
| |
| pattern = matcher.replaceFirst(""); //$NON-NLS-1$ |
| matcher.reset(pattern); |
| } |
| // pattern contains now no ranges |
| for (int i = 0; i < pattern.length(); i++) { |
| final char c = pattern.charAt(i); |
| characterClasses.add(new OneCharacterPattern(c)); |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| protected final boolean matches(char c) { |
| for (CharacterPattern pattern : characterClasses) { |
| if (pattern.matches(c)) { |
| return !inverse; |
| } |
| } |
| return inverse; |
| } |
| |
| private interface CharacterPattern { |
| /** |
| * @param c |
| * the character to test |
| * @return returns true if the character matches a pattern. |
| */ |
| boolean matches(char c); |
| } |
| |
| private static final class CharacterRange implements CharacterPattern { |
| private final char start; |
| |
| private final char end; |
| |
| CharacterRange(char start, char end) { |
| this.start = start; |
| this.end = end; |
| } |
| |
| @Override |
| public final boolean matches(char c) { |
| return start <= c && c <= end; |
| } |
| } |
| |
| private static final class DigitPattern implements CharacterPattern { |
| static final GroupHead.DigitPattern INSTANCE = new DigitPattern(); |
| |
| @Override |
| public final boolean matches(char c) { |
| return Character.isDigit(c); |
| } |
| } |
| |
| private static final class LetterPattern implements CharacterPattern { |
| static final GroupHead.LetterPattern INSTANCE = new LetterPattern(); |
| |
| @Override |
| public final boolean matches(char c) { |
| return Character.isLetter(c); |
| } |
| } |
| |
| private static final class LowerPattern implements CharacterPattern { |
| static final GroupHead.LowerPattern INSTANCE = new LowerPattern(); |
| |
| @Override |
| public final boolean matches(char c) { |
| return Character.isLowerCase(c); |
| } |
| } |
| |
| private static final class UpperPattern implements CharacterPattern { |
| static final GroupHead.UpperPattern INSTANCE = new UpperPattern(); |
| |
| @Override |
| public final boolean matches(char c) { |
| return Character.isUpperCase(c); |
| } |
| } |
| |
| private static final class WhitespacePattern implements CharacterPattern { |
| static final GroupHead.WhitespacePattern INSTANCE = new WhitespacePattern(); |
| |
| @Override |
| public final boolean matches(char c) { |
| return Character.isWhitespace(c); |
| } |
| } |
| |
| private static final class OneCharacterPattern implements CharacterPattern { |
| private char expectedCharacter; |
| |
| OneCharacterPattern(char c) { |
| this.expectedCharacter = c; |
| } |
| |
| @Override |
| public final boolean matches(char c) { |
| return this.expectedCharacter == c; |
| } |
| } |
| |
| private static final class PunctPattern implements CharacterPattern { |
| static final GroupHead.PunctPattern INSTANCE = new PunctPattern(); |
| |
| private static String punctCharacters = "-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; //$NON-NLS-1$ |
| |
| @Override |
| public boolean matches(char c) { |
| return punctCharacters.indexOf(c) != -1; |
| } |
| } |
| |
| } |