All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.codehaus.plexus.util.SelectorUtils Maven / Gradle / Ivy

/*
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2002-2003 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowledgement:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.codehaus.org/)."
 *    Alternately, this acknowledgement may appear in the software itself,
 *    if and wherever such third-party acknowledgements normally appear.
 *
 * 4. The names "Ant" and "Apache Software
 *    Foundation" must not be used to endorse or promote products derived
 *    from this software without prior written permission. For written
 *    permission, please contact [email protected].
 *
 * 5. Products derived from this software may not be called "Apache"
 *    nor may "Apache" appear in their names without prior written
 *    permission of the Apache Group.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * .
 */

package org.codehaus.plexus.util;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * 

This is a utility class used by selectors and DirectoryScanner. The functionality more properly belongs just to * selectors, but unfortunately DirectoryScanner exposed these as protected methods. Thus we have to support any * subclasses of DirectoryScanner that may access these methods.

* *

This is a Singleton.

* * @author Arnout J. Kuiper [email protected] * @author Magesh Umasankar * @author Bruce Atherton * * @since 1.5 */ public final class SelectorUtils { public static final String PATTERN_HANDLER_PREFIX = "["; public static final String PATTERN_HANDLER_SUFFIX = "]"; public static final String REGEX_HANDLER_PREFIX = "%regex" + PATTERN_HANDLER_PREFIX; public static final String ANT_HANDLER_PREFIX = "%ant" + PATTERN_HANDLER_PREFIX; private static SelectorUtils instance = new SelectorUtils(); /** * Private Constructor */ private SelectorUtils() {} /** * @return Retrieves the manager of the Singleton. */ public static SelectorUtils getInstance() { return instance; } /** *

Tests whether or not a given path matches the start of a given pattern up to the first "**".

* *

This is not a general purpose test and should only be used if you can live with false positives. For example, * pattern=**\a and str=b will yield true.

* * @param pattern The pattern to match against. Must not be null. * @param str The path to match, as a String. Must not be null. * @return whether or not a given path matches the start of a given pattern up to the first "**". */ public static boolean matchPatternStart(String pattern, String str) { return matchPatternStart(pattern, str, true); } /** *

Tests whether or not a given path matches the start of a given pattern up to the first "**".

* *

This is not a general purpose test and should only be used if you can live with false positives. For example, * pattern=**\a and str=b will yield true.

* * @param pattern The pattern to match against. Must not be null. * @param str The path to match, as a String. Must not be null. * @param isCaseSensitive Whether or not matching should be performed case sensitively. * @return whether or not a given path matches the start of a given pattern up to the first "**". */ public static boolean matchPatternStart(String pattern, String str, boolean isCaseSensitive) { if (isRegexPrefixedPattern(pattern)) { // FIXME: ICK! But we can't do partial matches for regex, so we have to reserve judgement until we have // a file to deal with, or we can definitely say this is an exclusion... return true; } else { if (isAntPrefixedPattern(pattern)) { pattern = pattern.substring( ANT_HANDLER_PREFIX.length(), pattern.length() - PATTERN_HANDLER_SUFFIX.length()); } String altStr = str.replace('\\', '/'); return matchAntPathPatternStart(pattern, str, File.separator, isCaseSensitive) || matchAntPathPatternStart(pattern, altStr, "/", isCaseSensitive); } } /** * @since 3.6 */ public static boolean isAntPrefixedPattern(String pattern) { return pattern.length() > (ANT_HANDLER_PREFIX.length() + PATTERN_HANDLER_SUFFIX.length()) && pattern.startsWith(ANT_HANDLER_PREFIX) && pattern.endsWith(PATTERN_HANDLER_SUFFIX); } @SuppressWarnings("SimplifiableIfStatement") static boolean matchAntPathPatternStart( MatchPattern pattern, String str, String separator, boolean isCaseSensitive) { if (separatorPatternStartSlashMismatch(pattern, str, separator)) { return false; } return matchAntPathPatternStart(pattern.getTokenizedPathString(), str, separator, isCaseSensitive); } static boolean matchAntPathPatternStart(String pattern, String str, String separator, boolean isCaseSensitive) { // When str starts with a File.separator, pattern has to start with a // File.separator. // When pattern starts with a File.separator, str has to start with a // File.separator. if (separatorPatternStartSlashMismatch(pattern, str, separator)) { return false; } String[] patDirs = tokenizePathToString(pattern, separator); return matchAntPathPatternStart(patDirs, str, separator, isCaseSensitive); } // When str starts with a File.separator, pattern has to start with a // File.separator. // When pattern starts with a File.separator, str has to start with a // File.separator. private static boolean separatorPatternStartSlashMismatch(String pattern, String str, String separator) { return str.startsWith(separator) != pattern.startsWith(separator); } private static boolean separatorPatternStartSlashMismatch(MatchPattern matchPattern, String str, String separator) { return str.startsWith(separator) != matchPattern.startsWith(separator); } static boolean matchAntPathPatternStart(String[] patDirs, String str, String separator, boolean isCaseSensitive) { String[] strDirs = tokenizePathToString(str, separator); int patIdxStart = 0; int patIdxEnd = patDirs.length - 1; int strIdxStart = 0; int strIdxEnd = strDirs.length - 1; // up to first '**' while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) { String patDir = patDirs[patIdxStart]; if (patDir.equals("**")) { break; } if (!match(patDir, strDirs[strIdxStart], isCaseSensitive)) { return false; } patIdxStart++; strIdxStart++; } return strIdxStart > strIdxEnd || patIdxStart <= patIdxEnd; } /** * Tests whether or not a given path matches a given pattern. * * @param pattern The pattern to match against. Must not be null. * @param str The path to match, as a String. Must not be null. * @return true if the pattern matches against the string, or false otherwise. */ public static boolean matchPath(String pattern, String str) { return matchPath(pattern, str, true); } /** * Tests whether or not a given path matches a given pattern. * * @param pattern The pattern to match against. Must not be null. * @param str The path to match, as a String. Must not be null. * @param isCaseSensitive Whether or not matching should be performed case sensitively. * @return true if the pattern matches against the string, or false otherwise. */ public static boolean matchPath(String pattern, String str, boolean isCaseSensitive) { return matchPath(pattern, str, File.separator, isCaseSensitive); } public static boolean matchPath(String pattern, String str, String separator, boolean isCaseSensitive) { if (isRegexPrefixedPattern(pattern)) { String localPattern = pattern.substring( REGEX_HANDLER_PREFIX.length(), pattern.length() - PATTERN_HANDLER_SUFFIX.length()); return str.matches(localPattern); } else { String localPattern = isAntPrefixedPattern(pattern) ? pattern.substring(ANT_HANDLER_PREFIX.length(), pattern.length() - PATTERN_HANDLER_SUFFIX.length()) : pattern; final String osRelatedPath = toOSRelatedPath(str, separator); final String osRelatedPattern = toOSRelatedPath(localPattern, separator); return matchAntPathPattern(osRelatedPattern, osRelatedPath, separator, isCaseSensitive); } } private static String toOSRelatedPath(String pattern, String separator) { if ("/".equals(separator)) { return pattern.replace("\\", separator); } if ("\\".equals(separator)) { return pattern.replace("/", separator); } return pattern; } /** * @since 3.6.0 */ public static boolean isRegexPrefixedPattern(String pattern) { return pattern.length() > (REGEX_HANDLER_PREFIX.length() + PATTERN_HANDLER_SUFFIX.length()) && pattern.startsWith(REGEX_HANDLER_PREFIX) && pattern.endsWith(PATTERN_HANDLER_SUFFIX); } static boolean matchAntPathPattern( MatchPattern matchPattern, String str, String separator, boolean isCaseSensitive) { if (separatorPatternStartSlashMismatch(matchPattern, str, separator)) { return false; } String[] patDirs = matchPattern.getTokenizedPathString(); String[] strDirs = tokenizePathToString(str, separator); return matchAntPathPattern(patDirs, strDirs, isCaseSensitive); } static boolean matchAntPathPattern(String pattern, String str, String separator, boolean isCaseSensitive) { if (separatorPatternStartSlashMismatch(pattern, str, separator)) { return false; } String[] patDirs = tokenizePathToString(pattern, separator); String[] strDirs = tokenizePathToString(str, separator); return matchAntPathPattern(patDirs, strDirs, isCaseSensitive); } static boolean matchAntPathPattern(String[] patDirs, String[] strDirs, boolean isCaseSensitive) { int patIdxStart = 0; int patIdxEnd = patDirs.length - 1; int strIdxStart = 0; int strIdxEnd = strDirs.length - 1; // up to first '**' while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) { String patDir = patDirs[patIdxStart]; if (patDir.equals("**")) { break; } if (!match(patDir, strDirs[strIdxStart], isCaseSensitive)) { return false; } patIdxStart++; strIdxStart++; } if (strIdxStart > strIdxEnd) { // String is exhausted for (int i = patIdxStart; i <= patIdxEnd; i++) { if (!patDirs[i].equals("**")) { return false; } } return true; } else { if (patIdxStart > patIdxEnd) { // String not exhausted, but pattern is. Failure. return false; } } // up to last '**' while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) { String patDir = patDirs[patIdxEnd]; if (patDir.equals("**")) { break; } if (!match(patDir, strDirs[strIdxEnd], isCaseSensitive)) { return false; } patIdxEnd--; strIdxEnd--; } if (strIdxStart > strIdxEnd) { // String is exhausted for (int i = patIdxStart; i <= patIdxEnd; i++) { if (!patDirs[i].equals("**")) { return false; } } return true; } while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) { int patIdxTmp = -1; for (int i = patIdxStart + 1; i <= patIdxEnd; i++) { if (patDirs[i].equals("**")) { patIdxTmp = i; break; } } if (patIdxTmp == patIdxStart + 1) { // '**/**' situation, so skip one patIdxStart++; continue; } // Find the pattern between padIdxStart & padIdxTmp in str between // strIdxStart & strIdxEnd int patLength = (patIdxTmp - patIdxStart - 1); int strLength = (strIdxEnd - strIdxStart + 1); int foundIdx = -1; strLoop: for (int i = 0; i <= strLength - patLength; i++) { for (int j = 0; j < patLength; j++) { String subPat = patDirs[patIdxStart + j + 1]; String subStr = strDirs[strIdxStart + i + j]; if (!match(subPat, subStr, isCaseSensitive)) { continue strLoop; } } foundIdx = strIdxStart + i; break; } if (foundIdx == -1) { return false; } patIdxStart = patIdxTmp; strIdxStart = foundIdx + patLength; } for (int i = patIdxStart; i <= patIdxEnd; i++) { if (!patDirs[i].equals("**")) { return false; } } return true; } static boolean matchAntPathPattern(char[][] patDirs, char[][] strDirs, boolean isCaseSensitive) { int patIdxStart = 0; int patIdxEnd = patDirs.length - 1; int strIdxStart = 0; int strIdxEnd = strDirs.length - 1; // up to first '**' while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) { char[] patDir = patDirs[patIdxStart]; if (isDoubleStar(patDir)) { break; } if (!match(patDir, strDirs[strIdxStart], isCaseSensitive)) { return false; } patIdxStart++; strIdxStart++; } if (strIdxStart > strIdxEnd) { // String is exhausted for (int i = patIdxStart; i <= patIdxEnd; i++) { if (!isDoubleStar(patDirs[i])) { return false; } } return true; } else { if (patIdxStart > patIdxEnd) { // String not exhausted, but pattern is. Failure. return false; } } // up to last '**' while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) { char[] patDir = patDirs[patIdxEnd]; if (isDoubleStar(patDir)) { break; } if (!match(patDir, strDirs[strIdxEnd], isCaseSensitive)) { return false; } patIdxEnd--; strIdxEnd--; } if (strIdxStart > strIdxEnd) { // String is exhausted for (int i = patIdxStart; i <= patIdxEnd; i++) { if (!isDoubleStar(patDirs[i])) { return false; } } return true; } while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) { int patIdxTmp = -1; for (int i = patIdxStart + 1; i <= patIdxEnd; i++) { if (isDoubleStar(patDirs[i])) { patIdxTmp = i; break; } } if (patIdxTmp == patIdxStart + 1) { // '**/**' situation, so skip one patIdxStart++; continue; } // Find the pattern between padIdxStart & padIdxTmp in str between // strIdxStart & strIdxEnd int patLength = (patIdxTmp - patIdxStart - 1); int strLength = (strIdxEnd - strIdxStart + 1); int foundIdx = -1; strLoop: for (int i = 0; i <= strLength - patLength; i++) { for (int j = 0; j < patLength; j++) { char[] subPat = patDirs[patIdxStart + j + 1]; char[] subStr = strDirs[strIdxStart + i + j]; if (!match(subPat, subStr, isCaseSensitive)) { continue strLoop; } } foundIdx = strIdxStart + i; break; } if (foundIdx == -1) { return false; } patIdxStart = patIdxTmp; strIdxStart = foundIdx + patLength; } for (int i = patIdxStart; i <= patIdxEnd; i++) { if (!isDoubleStar(patDirs[i])) { return false; } } return true; } private static boolean isDoubleStar(char[] patDir) { return patDir != null && patDir.length == 2 && patDir[0] == '*' && patDir[1] == '*'; } /** * Tests whether or not a string matches against a pattern. The pattern may contain two special characters:
* '*' means zero or more characters
* '?' means one and only one character * * @param pattern The pattern to match against. Must not be null. * @param str The string which must be matched against the pattern. Must not be null. * @return true if the string matches against the pattern, or false otherwise. */ public static boolean match(String pattern, String str) { return match(pattern, str, true); } /** * Tests whether or not a string matches against a pattern. The pattern may contain two special characters:
* '*' means zero or more characters
* '?' means one and only one character * * @param pattern The pattern to match against. Must not be null. * @param str The string which must be matched against the pattern. Must not be null. * @param isCaseSensitive Whether or not matching should be performed case sensitively. * @return true if the string matches against the pattern, or false otherwise. */ public static boolean match(String pattern, String str, boolean isCaseSensitive) { char[] patArr = pattern.toCharArray(); char[] strArr = str.toCharArray(); return match(patArr, strArr, isCaseSensitive); } public static boolean match(char[] patArr, char[] strArr, boolean isCaseSensitive) { int patIdxStart = 0; int patIdxEnd = patArr.length - 1; int strIdxStart = 0; int strIdxEnd = strArr.length - 1; char ch; boolean containsStar = false; for (char aPatArr : patArr) { if (aPatArr == '*') { containsStar = true; break; } } if (!containsStar) { // No '*'s, so we make a shortcut if (patIdxEnd != strIdxEnd) { return false; // Pattern and string do not have the same size } for (int i = 0; i <= patIdxEnd; i++) { ch = patArr[i]; if (ch != '?' && !equals(ch, strArr[i], isCaseSensitive)) { return false; // Character mismatch } } return true; // String matches against pattern } if (patIdxEnd == 0) { return true; // Pattern contains only '*', which matches anything } // Process characters before first star while ((ch = patArr[patIdxStart]) != '*' && strIdxStart <= strIdxEnd) { if (ch != '?' && !equals(ch, strArr[strIdxStart], isCaseSensitive)) { return false; // Character mismatch } patIdxStart++; strIdxStart++; } if (strIdxStart > strIdxEnd) { // All characters in the string are used. Check if only '*'s are // left in the pattern. If so, we succeeded. Otherwise failure. for (int i = patIdxStart; i <= patIdxEnd; i++) { if (patArr[i] != '*') { return false; } } return true; } // Process characters after last star while ((ch = patArr[patIdxEnd]) != '*' && strIdxStart <= strIdxEnd) { if (ch != '?' && !equals(ch, strArr[strIdxEnd], isCaseSensitive)) { return false; // Character mismatch } patIdxEnd--; strIdxEnd--; } if (strIdxStart > strIdxEnd) { // All characters in the string are used. Check if only '*'s are // left in the pattern. If so, we succeeded. Otherwise failure. for (int i = patIdxStart; i <= patIdxEnd; i++) { if (patArr[i] != '*') { return false; } } return true; } // process pattern between stars. padIdxStart and patIdxEnd point // always to a '*'. while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) { int patIdxTmp = -1; for (int i = patIdxStart + 1; i <= patIdxEnd; i++) { if (patArr[i] == '*') { patIdxTmp = i; break; } } if (patIdxTmp == patIdxStart + 1) { // Two stars next to each other, skip the first one. patIdxStart++; continue; } // Find the pattern between padIdxStart & padIdxTmp in str between // strIdxStart & strIdxEnd int patLength = (patIdxTmp - patIdxStart - 1); int strLength = (strIdxEnd - strIdxStart + 1); int foundIdx = -1; strLoop: for (int i = 0; i <= strLength - patLength; i++) { for (int j = 0; j < patLength; j++) { ch = patArr[patIdxStart + j + 1]; if (ch != '?' && !equals(ch, strArr[strIdxStart + i + j], isCaseSensitive)) { continue strLoop; } } foundIdx = strIdxStart + i; break; } if (foundIdx == -1) { return false; } patIdxStart = patIdxTmp; strIdxStart = foundIdx + patLength; } // All characters in the string are used. Check if only '*'s are left // in the pattern. If so, we succeeded. Otherwise failure. for (int i = patIdxStart; i <= patIdxEnd; i++) { if (patArr[i] != '*') { return false; } } return true; } /** * Tests whether two characters are equal. */ private static boolean equals(char c1, char c2, boolean isCaseSensitive) { if (c1 == c2) { return true; } if (!isCaseSensitive) { // NOTE: Try both upper case and lower case as done by String.equalsIgnoreCase() if (Character.toUpperCase(c1) == Character.toUpperCase(c2) || Character.toLowerCase(c1) == Character.toLowerCase(c2)) { return true; } } return false; } private static String[] tokenizePathToString(String path, String separator) { List ret = new ArrayList(); StringTokenizer st = new StringTokenizer(path, separator); while (st.hasMoreTokens()) { ret.add(st.nextToken()); } return ret.toArray(new String[0]); } /** * Returns dependency information on these two files. If src has been modified later than target, it returns true. * If target doesn't exist, it likewise returns true. Otherwise, target is newer than src and is not out of date, * thus the method returns false. It also returns false if the src file doesn't even exist, since how could the * target then be out of date. * * @param src the original file * @param target the file being compared against * @param granularity the amount in seconds of slack we will give in determining out of dateness * @return whether the target is out of date */ public static boolean isOutOfDate(File src, File target, int granularity) { if (!src.exists()) { return false; } if (!target.exists()) { return true; } if ((src.lastModified() - granularity) > target.lastModified()) { return true; } return false; } /** * "Flattens" a string by removing all whitespace (space, tab, linefeed, carriage return, and formfeed). This uses * StringTokenizer and the default set of tokens as documented in the single argument constructor. * * @param input a String to remove all whitespace. * @return a String that has had all whitespace removed. */ public static String removeWhitespace(String input) { StringBuilder result = new StringBuilder(); if (input != null) { StringTokenizer st = new StringTokenizer(input); while (st.hasMoreTokens()) { result.append(st.nextToken()); } } return result.toString(); } /** * Extract the pattern without the Regex or Ant prefix. In the case of Ant style matches ensure * that the path uses specified separator. * @param pattern the pattern to extract from. * @param separator the system file name separator in the pattern. * @return The pattern without the Regex or Ant prefix. * @since 3.6.0 */ public static String extractPattern(final String pattern, final String separator) { if (isRegexPrefixedPattern(pattern)) { return pattern.substring(REGEX_HANDLER_PREFIX.length(), pattern.length() - PATTERN_HANDLER_SUFFIX.length()); } else { String localPattern = isAntPrefixedPattern(pattern) ? pattern.substring(ANT_HANDLER_PREFIX.length(), pattern.length() - PATTERN_HANDLER_SUFFIX.length()) : pattern; return toOSRelatedPath(localPattern, separator); } } }




© 2015 - 2025 Weber Informatics LLC | Privacy Policy