Refactors DefaultFilters and DefaultFiltersTest to accept a filter that will return .class files. Review at http://gwt-code-reviews.appspot.com/1336801 git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@9661 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/core/src/com/google/gwt/dev/resource/impl/DefaultFilters.java b/dev/core/src/com/google/gwt/dev/resource/impl/DefaultFilters.java index 48398e6..7cec82a 100644 --- a/dev/core/src/com/google/gwt/dev/resource/impl/DefaultFilters.java +++ b/dev/core/src/com/google/gwt/dev/resource/impl/DefaultFilters.java
@@ -38,254 +38,92 @@ */ public class DefaultFilters { - private static final boolean IS_EXCLUDES = false; - private static final boolean IS_INCLUDES = true; - private static final boolean NOT_JAVA = false; - private static final boolean YES_JAVA = true; + /** + * Constants to represent the type of files that will be filtered. + */ + public static enum FilterFileType { + RESOURCE_FILES(null), // + JAVA_FILES(".java"), // + CLASS_FILES(".class"); - static ZipScanner getScanner(String[] includeList, String[] excludeList, - String[] skipList, boolean defaultExcludes, boolean caseSensitive) { - /* - * Hijack Ant's ZipScanner to handle inclusions/exclusions exactly as Ant - * does. We're only using its pattern-matching capabilities; the code path - * I'm using never tries to hit the filesystem in Ant 1.6.5. - */ - ZipScanner scanner = new ZipScanner(); - if (includeList.length > 0) { - scanner.setIncludes(includeList); - } - if (excludeList.length > 0 || skipList.length > 0) { - String[] excludeOrSkip = concatenate(excludeList, skipList); - scanner.setExcludes(excludeOrSkip); - } - if (defaultExcludes) { - scanner.addDefaultExcludes(); - } - scanner.setCaseSensitive(caseSensitive); - scanner.init(); + private final String suffix; - return scanner; - } + /* used when defaultExcludes is false */ + private final ResourceFilter justThisFileTypeFilter = new ResourceFilter() { + public boolean allows(String path) { + return defaultAntIncludes.allows(path) && matches(path); + } + }; + + private final ResourceFilter defaultFilter = new ResourceFilter() { - private static String[] concatenate(String[] array1, String[] array2) { - String[] answer = new String[array1.length + array2.length]; - int i = 0; - for (String entry : array1) { - answer[i++] = entry; + public boolean allows(String path) { + return getFileTypeFilter().allows(path) + && !defaultExcludesPattern.matcher(path).matches(); + } + }; + + private FilterFileType(String suffix) { + this.suffix = suffix; } - for (String entry : array2) { - answer[i++] = entry; + + public ResourceFilter getDefaultFilter() { + return defaultFilter; } - return answer; + + /* used when defaultExcludes is false */ + public ResourceFilter getFileTypeFilter() { + return justThisFileTypeFilter; + } + + public String getSuffix() { + return suffix; + } + + public boolean matches(String path) { + if (suffix == null) { + return true; + } + return path.endsWith(suffix); + } } - /* used when defaultExcludes is true */ - final ResourceFilter defaultResourceFilter = new ResourceFilter() { + /* + * list copied from {@link org.apache.tools.ant.DirectoryScanner} + */ + private static final String DEFAULT_EXCLUDES[] = new String[]{ + // Miscellaneous typical temporary files + "**/*~", "**/#*#", "**/.#*", "**/%*%", "**/._*", - public boolean allows(String path) { - return defaultAntIncludes.allows(path) - && !defaultExcludesPattern.matcher(path).matches(); - } - }; + // CVS + "**/CVS", "**/CVS/**", + // to not hit the weird formatting error. + "**/.cvsignore", - /* used when defaultExcludes is true */ - final ResourceFilter defaultJavaFilter = new ResourceFilter() { + // SCCS + "**/SCCS", "**/SCCS/**", - public boolean allows(String path) { - return justJavaFilter.allows(path) - && !defaultJavaExcludesPattern.matcher(path).matches(); - } + // Visual SourceSafe + "**/vssver.scc", - }; - /* used when defaultExcludes is false */ - final ResourceFilter justResourceFilter = new ResourceFilter() { + // Subversion + "**/.svn", "**/.svn/**", - public boolean allows(String path) { - return defaultAntIncludes.allows(path); - } - }; + // Mac + "**/.DS_Store",}; - /* used when defaultExcludes is false */ - final ResourceFilter justJavaFilter = new ResourceFilter() { - - public boolean allows(String path) { - return defaultAntIncludes.allows(path) && isJavaFile(path); - } - }; - - private final Pattern defaultExcludesPattern; - private final Pattern defaultJavaExcludesPattern; // \w (word character), ., $, /, -, *, ~, #, % - private final Pattern antPattern = Pattern.compile("^[\\w\\.\\$/\\-\\*~#%]*$"); + private static final Pattern antPattern = Pattern.compile("^[\\w\\.\\$/\\-\\*~#%]*$"); + + private static final Pattern defaultExcludesPattern = getPatternFromAntStrings(DEFAULT_EXCLUDES); // accepts all but paths starting with '/'. Default include list is '**' - private final ResourceFilter defaultAntIncludes = new ResourceFilter() { + private static final ResourceFilter defaultAntIncludes = new ResourceFilter() { public boolean allows(String path) { return path.charAt(0) != '/'; } }; - private final ResourceFilter rejectAll = new ResourceFilter() { - public boolean allows(String path) { - return false; - } - }; - - public DefaultFilters() { - - /* - * list copied from {@link org.apache.tools.ant.DirectoryScanner} - */ - String defaultExcludes[] = new String[] { - // Miscellaneous typical temporary files - "**/*~", "**/#*#", "**/.#*", "**/%*%", "**/._*", - - // CVS - "**/CVS", "**/CVS/**", - // to not hit the weird formatting error. - "**/.cvsignore", - - // SCCS - "**/SCCS", "**/SCCS/**", - - // Visual SourceSafe - "**/vssver.scc", - - // Subversion - "**/.svn", "**/.svn/**", - - // Mac - "**/.DS_Store",}; - - defaultExcludesPattern = getPatternFromAntStrings(defaultExcludes); - - String defaultExcludesJava[] = new String[] { - // Miscellaneous typical temporary files - "**/.#*", "**/._*", - - // CVS - "**/CVS/**", - - // SCCS - "**/SCCS/**", - - // Subversion - "**/.svn/**",}; - defaultJavaExcludesPattern = getPatternFromAntStrings(defaultExcludesJava); - } - - public ResourceFilter customJavaFilter(String includeList[], - String excludeList[], String skipList[], boolean defaultExcludes, - boolean caseSensitive) { - return getCustomFilter(includeList, excludeList, skipList, defaultExcludes, - caseSensitive, YES_JAVA); - } - - public ResourceFilter customResourceFilter(String includeList[], - String excludeList[], String[] skipList, boolean defaultExcludes, - boolean caseSensitive) { - - return getCustomFilter(includeList, excludeList, skipList, defaultExcludes, - caseSensitive, NOT_JAVA); - } - - /** - * return a customResourceFiter that handles all the argument. If unable to - * create a customResourceFilter that handles the arguments, catchAll is used - * as the final ResourceFilter. - */ - ResourceFilter customFilterWithCatchAll(final String includeList[], - final String excludeList[], final String skipList[], - final boolean defaultExcludes, final ResourceFilter catchAll, - final boolean isJava) { - - assert includeList.length > 0 || excludeList.length > 0 || skipList.length > 0; - - final ResourceFilter includeFilter = getFilterPart(includeList, IS_INCLUDES); - final ResourceFilter excludeFilter = getFilterPart(concatenate(excludeList, skipList), - IS_EXCLUDES); - - if (includeFilter == null || excludeFilter == null) { - return catchAll; - } - // another common-case - ResourceFilter filter = new ResourceFilter() { - public boolean allows(String path) { - // do not handle the case when pattern ends in '/' - if (path.endsWith("/")) { - return catchAll.allows(path); - } - return isPathAllowedByDefaults(path, defaultExcludes, isJava) - && includeFilter.allows(path) && !excludeFilter.allows(path); - } - - private boolean isPathAllowedByDefaults(String path, - boolean defaultExcludes, boolean isJava) { - if (defaultExcludes) { - return isJava ? !defaultJavaExcludesPattern.matcher(path).matches() - && isJavaFile(path) - : !defaultExcludesPattern.matcher(path).matches(); - } - return isJava ? isJavaFile(path) : true; - } - }; - return filter; - } - - ResourceFilter getCustomFilter(final String includeList[], - final String excludeList[], final String skipList[], - final boolean defaultExcludes, final boolean caseSensitive, - final boolean isJava) { - if (includeList.length == 0 && excludeList.length == 0 && - skipList.length == 0 && caseSensitive) { - // optimize for the common case. - return getMatchingDefaultFilter(defaultExcludes, isJava); - } - - // don't create a catchAll in default cases - ResourceFilter catchAll = new ResourceFilter() { - ZipScanner scanner = getScanner(includeList, excludeList, - skipList, defaultExcludes, caseSensitive); - - public boolean allows(String path) { - if (isJava) { - return isJavaFile(path) && scanner.match(path); - } - return scanner.match(path); - } - }; - - // for now, don't handle case sensitivity - if (!caseSensitive) { - return catchAll; - } - return customFilterWithCatchAll(includeList, excludeList, skipList, defaultExcludes, - catchAll, isJava); - } - - ResourceFilter getFilterPart(final String list[], final boolean defaultValue) { - if (list.length == 0) { - return defaultValue ? defaultAntIncludes : rejectAll; - } - - String patternStrings[] = new String[list.length]; - int count = 0; - for (String antPatternString : list) { - String patternString = getPatternFromAntPattern(antPatternString); - if (patternString == null) { - return null; - } - patternStrings[count++] = patternString; - } - - final Pattern pattern = getPatternFromStrings(patternStrings); - return new ResourceFilter() { - public boolean allows(String path) { - return pattern.matcher(path).matches(); - } - }; - } - /** * Returns a pattern string that can be passed in Java Pattern.compile(..). * For spec, see <a href="http://www.jajakarta.org/ant/ant-1.6.1/docs/ja/manual/api/org/apache/tools/ant/DirectoryScanner.html" @@ -305,7 +143,7 @@ * @return a pattern string that can be passed in Java's Pattern.compile(..), * null if cannot process the pattern. */ - String getPatternFromAntPattern(String antPatternString) { + static String getPatternFromAntPattern(String antPatternString) { if (!antPattern.matcher(antPatternString).matches()) { return null; } @@ -381,20 +219,43 @@ return sb.toString(); } - /** - * Obtain the appropriate resourceFilter based on defaultExcludes and isJava - * values. Assumptions: caseSensitive = true,and the includesList and - * excludesList are empty - */ - private ResourceFilter getMatchingDefaultFilter(boolean defaultExcludes, - boolean isJava) { - if (defaultExcludes) { - return isJava ? defaultJavaFilter : defaultResourceFilter; + static ZipScanner getScanner(String[] includeList, String[] excludeList, + String[] skipList, boolean defaultExcludes, boolean caseSensitive) { + /* + * Hijack Ant's ZipScanner to handle inclusions/exclusions exactly as Ant + * does. We're only using its pattern-matching capabilities; the code path + * I'm using never tries to hit the filesystem in Ant 1.6.5. + */ + ZipScanner scanner = new ZipScanner(); + if (includeList.length > 0) { + scanner.setIncludes(includeList); } - return isJava ? justJavaFilter : justResourceFilter; + if (excludeList.length > 0 || skipList.length > 0) { + String[] excludeOrSkip = concatenate(excludeList, skipList); + scanner.setExcludes(excludeOrSkip); + } + if (defaultExcludes) { + scanner.addDefaultExcludes(); + } + scanner.setCaseSensitive(caseSensitive); + scanner.init(); + + return scanner; } - private Pattern getPatternFromAntStrings(String... antPatterns) { + private static String[] concatenate(String[] array1, String[] array2) { + String[] answer = new String[array1.length + array2.length]; + int i = 0; + for (String entry : array1) { + answer[i++] = entry; + } + for (String entry : array2) { + answer[i++] = entry; + } + return answer; + } + + private static Pattern getPatternFromAntStrings(String... antPatterns) { String patternStrings[] = new String[antPatterns.length]; int count = 0; for (String antPatternString : antPatterns) { @@ -408,7 +269,7 @@ return getPatternFromStrings(patternStrings); } - private Pattern getPatternFromStrings(String... patterns) { + private static Pattern getPatternFromStrings(String... patterns) { StringBuffer entirePattern = new StringBuffer("^"); int length = patterns.length; int count = 0; @@ -423,7 +284,156 @@ return Pattern.compile(entirePattern.toString()); } - private boolean isJavaFile(String path) { - return path.endsWith(".java"); + private final ResourceFilter rejectAll = new ResourceFilter() { + public boolean allows(String path) { + return false; + } + }; + + public ResourceFilter customClassFilesFilter(String includeList[], + String excludeList[], String skipList[], boolean defaultExcludes, + boolean caseSensitive) { + return getCustomFilter(includeList, excludeList, skipList, defaultExcludes, + caseSensitive, FilterFileType.CLASS_FILES); + } + + public ResourceFilter customJavaFilter(String includeList[], + String excludeList[], String skipList[], boolean defaultExcludes, + boolean caseSensitive) { + return getCustomFilter(includeList, excludeList, skipList, defaultExcludes, + caseSensitive, FilterFileType.JAVA_FILES); + } + + public ResourceFilter customResourceFilter(String includeList[], + String excludeList[], String[] skipList, boolean defaultExcludes, + boolean caseSensitive) { + return getCustomFilter(includeList, excludeList, skipList, defaultExcludes, + caseSensitive, FilterFileType.RESOURCE_FILES); + } + + /** + * Return a customResourceFiter that handles all the argument. If unable to + * create a customResourceFilter that handles the arguments, catchAll is used + * as the final ResourceFilter. + */ + ResourceFilter customFilterWithCatchAll(final String includeList[], + final String excludeList[], final String skipList[], + final boolean defaultExcludes, final ResourceFilter catchAll, + final FilterFileType filterFileType) { + + assert includeList.length > 0 || excludeList.length > 0 + || skipList.length > 0; + + final ResourceFilter includeFilter = getIncludesFilterPart(includeList); + final ResourceFilter excludeFilter = getExcludesFilterPart(concatenate( + excludeList, skipList)); + + if (includeFilter == null || excludeFilter == null) { + return catchAll; + } + // another common-case + ResourceFilter filter = new ResourceFilter() { + public boolean allows(String path) { + // do not handle the case when pattern ends in '/' + if (path.endsWith("/")) { + return catchAll.allows(path); + } + return isPathAllowedByDefaults(path, defaultExcludes, filterFileType) + && includeFilter.allows(path) && !excludeFilter.allows(path); + } + + private boolean isPathAllowedByDefaults(String path, + boolean defaultExcludes, FilterFileType filterFileType) { + boolean fileTypeMatch = filterFileType.matches(path); + if (!fileTypeMatch) { + return false; + } + if (defaultExcludes) { + return !defaultExcludesPattern.matcher(path).matches(); + } + return true; + } + }; + return filter; + } + + ResourceFilter getCustomFilter(final String includeList[], + final String excludeList[], final String skipList[], + final boolean defaultExcludes, final boolean caseSensitive, + final FilterFileType filterFileType) { + if (includeList.length == 0 && excludeList.length == 0 + && skipList.length == 0 && caseSensitive) { + // optimize for the common case. + return getMatchingDefaultFilter(defaultExcludes, filterFileType); + } + + // don't create a catchAll in default cases + ResourceFilter catchAll = new ResourceFilter() { + ZipScanner scanner = getScanner(includeList, excludeList, skipList, + defaultExcludes, caseSensitive); + + public boolean allows(String path) { + return filterFileType.matches(path) && scanner.match(path); + } + }; + + // for now, don't handle case sensitivity + if (!caseSensitive) { + return catchAll; + } + return customFilterWithCatchAll(includeList, excludeList, skipList, + defaultExcludes, catchAll, filterFileType); + } + + ResourceFilter getExcludesFilterPart(final String list[]) { + return getFilterPart(list, false); + } + + ResourceFilter getIncludesFilterPart(final String list[]) { + return getFilterPart(list, true); + } + + /** + * @param list patterns to add to the filter. + * @param isInclude Only used if the the array is empty. If <code>true</code> + * treat this as an include. Otherwise, assume this is an excludes + * filter and exclude all files. + * @return + */ + private ResourceFilter getFilterPart(final String list[], + final boolean isInclude) { + if (list.length == 0) { + return isInclude ? defaultAntIncludes : rejectAll; + } + + String patternStrings[] = new String[list.length]; + int count = 0; + for (String antPatternString : list) { + String patternString = getPatternFromAntPattern(antPatternString); + if (patternString == null) { + return null; + } + patternStrings[count++] = patternString; + } + + final Pattern pattern = getPatternFromStrings(patternStrings); + return new ResourceFilter() { + public boolean allows(String path) { + return pattern.matcher(path).matches(); + } + }; + } + + /** + * Obtain the appropriate resourceFilter based on defaultExcludes and isJava + * values. Assumptions: caseSensitive = true,and the includesList and + * excludesList are empty + */ + private ResourceFilter getMatchingDefaultFilter(boolean defaultExcludes, + FilterFileType filterFileType) { + if (defaultExcludes) { + return filterFileType.getDefaultFilter(); + } + return filterFileType.getFileTypeFilter(); } }
diff --git a/dev/core/test/com/google/gwt/dev/resource/impl/DefaultFiltersTest.java b/dev/core/test/com/google/gwt/dev/resource/impl/DefaultFiltersTest.java index 3069d55..e592c6e 100644 --- a/dev/core/test/com/google/gwt/dev/resource/impl/DefaultFiltersTest.java +++ b/dev/core/test/com/google/gwt/dev/resource/impl/DefaultFiltersTest.java
@@ -15,6 +15,8 @@ */ package com.google.gwt.dev.resource.impl; +import com.google.gwt.dev.resource.impl.DefaultFilters.FilterFileType; + import junit.framework.TestCase; import org.apache.tools.ant.types.ZipScanner; @@ -51,29 +53,39 @@ String baseExcluded[] = mergeArrays(baseExcludedTesting, baseExcludedExact, baseExcludedDoubleStar); - void testAdvancedJavaPath(ResourceFilterString expected, - ResourceFilterString actual) { + void testAdvancedPath(ResourceFilterString expected, + ResourceFilterString actual, String suffix) { for (String path : mergeArrays(baseIncluded, baseExcluded, getMiscPaths( "testing", false).toArray(EMPTY_ARRAY), getMiscPaths("a/bc/de", false).toArray(EMPTY_ARRAY))) { - assertEquals(path + ".java", expected, actual); + assertEquals(path + suffix, expected, actual); + } + } + + void testAdvancedPathAnt(ResourceFilterString expected, + ResourceFilterString actual, String suffix) { + for (String path : mergeArrays(baseIncluded, baseExcluded, getMiscPaths( + "testing", true).toArray(EMPTY_ARRAY), + getMiscPaths("a/bc/de", true).toArray(EMPTY_ARRAY))) { + assertEquals(EXCLUDED_CHARS + path + EXCLUDED_CHARS + suffix, + expected, actual); + assertEquals(path + EXCLUDED_CHARS + suffix, expected, actual); + assertEquals(path + suffix, expected, actual); } + testAdvancedPath(expected, actual, suffix); + new BasicPaths().testBasicPath(expected, actual, suffix); + } + + void testAdvancedClassFilesPathAnt(ResourceFilterString expected, + ResourceFilterString actual) { + testAdvancedPathAnt(expected, actual, CLASS_FILE_SUFFIX); } void testAdvancedJavaPathAnt(ResourceFilterString expected, ResourceFilterString actual) { - for (String path : mergeArrays(baseIncluded, baseExcluded, getMiscPaths( - "testing", true).toArray(EMPTY_ARRAY), - getMiscPaths("a/bc/de", true).toArray(EMPTY_ARRAY))) { - assertEquals(excludedChars + path + excludedChars + javaSuffix, - expected, actual); - assertEquals(path + excludedChars + javaSuffix, expected, actual); - assertEquals(path + javaSuffix, expected, actual); - } - testAdvancedJavaPath(expected, actual); - new BasicPaths().testBasicJavaPath(expected, actual); + testAdvancedPathAnt(expected, actual, JAVA_FILE_SUFFIX); } - + void testAdvancedPath(ResourceFilterString expected, ResourceFilterString actual) { for (String path : mergeArrays(baseIncluded, baseExcluded, getMiscPaths( @@ -89,8 +101,8 @@ "testing", true).toArray(EMPTY_ARRAY), getMiscPaths("a/bc/de", true).toArray(EMPTY_ARRAY))) { assertEquals(path, expected, actual); - assertEquals(path + excludedChars, expected, actual); - assertEquals(excludedChars + path + excludedChars, expected, actual); + assertEquals(path + EXCLUDED_CHARS, expected, actual); + assertEquals(EXCLUDED_CHARS + path + EXCLUDED_CHARS, expected, actual); } testAdvancedPath(expected, actual); new BasicPaths().testBasicPath(expected, actual); @@ -106,20 +118,20 @@ "foo/.cvsignore", "foo/CVS", "foo/.svn", "foo/SCCS", "foo/bar/vssver.scc", "/foo/bar/.DS_Store"}; - void testBasicJavaPath(ResourceFilterString expected, - ResourceFilterString actual) { + void testBasicPath(ResourceFilterString expected, + ResourceFilterString actual, String suffix) { for (String str : mergeArrays(baseIncluded, baseExcluded, baseSuffixExcluded, getMiscPaths("testing", true).toArray(EMPTY_ARRAY), getMiscPaths( "a/bc/de", true).toArray(EMPTY_ARRAY))) { assertEquals(str, expected, actual); - assertEquals(str + javaSuffix, expected, actual); - assertEquals(excludedChars + str, expected, actual); - assertEquals(excludedChars + str + excludedChars, expected, actual); - assertEquals(excludedChars + str + javaSuffix, expected, actual); - assertEquals(excludedChars + str + excludedChars + javaSuffix, + assertEquals(str + suffix, expected, actual); + assertEquals(EXCLUDED_CHARS + str, expected, actual); + assertEquals(EXCLUDED_CHARS + str + EXCLUDED_CHARS, expected, actual); + assertEquals(EXCLUDED_CHARS + str + suffix, expected, actual); + assertEquals(EXCLUDED_CHARS + str + EXCLUDED_CHARS + suffix, expected, actual); - } + } } void testBasicPath(ResourceFilterString expected, @@ -129,8 +141,8 @@ getMiscPaths("testing", true).toArray(EMPTY_ARRAY), getMiscPaths( "a/bc/de", true).toArray(EMPTY_ARRAY))) { assertEquals(str, expected, actual); - assertEquals(excludedChars + str, expected, actual); - assertEquals(excludedChars + str + excludedChars, expected, actual); + assertEquals(EXCLUDED_CHARS + str, expected, actual); + assertEquals(EXCLUDED_CHARS + str + EXCLUDED_CHARS, expected, actual); } } } @@ -146,28 +158,25 @@ this.filter = filter; this.stringRepresentation = stringRepresentation; } - } private static final String EMPTY_ARRAY[] = new String[0]; private static final boolean DEFAULT_EXCLUDES = true; private static final boolean DEFAULT_INCLUDES = false; - private static final boolean NOT_JAVA = false; - private static final boolean YES_JAVA = true; - - private static final String mergedPatterns[] = { + private static final String JAVA_FILE_SUFFIX = ".java"; + private static final String CLASS_FILE_SUFFIX = ".class"; + + private static final String MERGED_PATTERNS[] = { "**/testing/**", "Foo", "Bar", "fooz/**", "barz/hello/**"}; // careful that the pattern is still permitted by ant. - private static final String excludedChars = "#~%*"; - - private static final String javaSuffix = ".java"; + private static final String EXCLUDED_CHARS = "#~%*"; private static void assertEquals(String path, ResourceFilterString expected, ResourceFilterString actual) { boolean scanResult = expected.filter.allows(path); assertEquals("String to be matched = " + path + ", actual filter = " - + actual.stringRepresentation + " should yied " + scanResult + + actual.stringRepresentation + " should yield " + scanResult + ", expected Filter = " + expected.stringRepresentation, scanResult, actual.filter.allows(path)); } @@ -215,26 +224,38 @@ public void testEmptyFilters() { BasicPaths basicPaths = new BasicPaths(); - DefaultFilters defaultFilters = new DefaultFilters(); - + FilterFileType fileType; + // first arg: ant filter, second arg: our custom filter + fileType= FilterFileType.RESOURCE_FILES; basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, - EMPTY_ARRAY, DEFAULT_EXCLUDES, NOT_JAVA, "antDefaultFilter"), - new ResourceFilterString(defaultFilters.defaultResourceFilter, + EMPTY_ARRAY, DEFAULT_EXCLUDES, fileType, "antDefaultFilter"), + new ResourceFilterString(fileType.getDefaultFilter(), "defaultFilter")); basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, - EMPTY_ARRAY, DEFAULT_INCLUDES, NOT_JAVA, "antDefaultIncludesFilter"), - new ResourceFilterString(defaultFilters.justResourceFilter, + EMPTY_ARRAY, DEFAULT_INCLUDES, fileType, "antDefaultIncludesFilter"), + new ResourceFilterString(fileType.getFileTypeFilter(), "defaultIncludesFilter")); - basicPaths.testBasicJavaPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, - EMPTY_ARRAY, DEFAULT_EXCLUDES, YES_JAVA, "antDefaultJavaFilter"), - new ResourceFilterString(defaultFilters.defaultJavaFilter, - "defaultJavaFilter")); - basicPaths.testBasicJavaPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, - EMPTY_ARRAY, DEFAULT_INCLUDES, YES_JAVA, "antJustJavaFilter"), - new ResourceFilterString(defaultFilters.justJavaFilter, - "justJavaFilter")); + fileType = FilterFileType.JAVA_FILES; + basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, + EMPTY_ARRAY, DEFAULT_EXCLUDES, fileType, "antDefaultJavaFilter"), + new ResourceFilterString(fileType.getDefaultFilter(), + "defaultJavaFilter"), fileType.getSuffix()); + basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, + EMPTY_ARRAY, DEFAULT_INCLUDES, fileType, "antJustJavaFilter"), + new ResourceFilterString(fileType.getFileTypeFilter(), + "justJavaFilter"), fileType.getSuffix()); + + fileType = FilterFileType.CLASS_FILES; + basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, + EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, "antDefaultClassFilesFilter"), + new ResourceFilterString(fileType.getDefaultFilter(), + "defaultClassFilesFilter"), fileType.getSuffix()); + basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, + EMPTY_ARRAY, DEFAULT_INCLUDES, FilterFileType.CLASS_FILES, "antJustClassFilesFilter"), + new ResourceFilterString(fileType.getFileTypeFilter(), + "justClassFilesFilter"), fileType.getSuffix()); } /** @@ -271,10 +292,10 @@ ResourceFilterString antFilterString = getAntFilter( new String[] {filter}, EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, - NOT_JAVA, "ant_" + filter); + FilterFileType.RESOURCE_FILES, "ant_" + filter); ResourceFilterString customFilterString = new ResourceFilterString( filters.customFilterWithCatchAll(new String[] {filter}, EMPTY_ARRAY, - EMPTY_ARRAY, true, null, NOT_JAVA), "custom_" + pattern); + EMPTY_ARRAY, true, null, FilterFileType.RESOURCE_FILES), "custom_" + pattern); for (String path : testPaths) { assertEquals(path, antFilterString, customFilterString); } @@ -286,20 +307,20 @@ ResourceFilter filter = null; // everything except those starting with '/' should be included - filter = new DefaultFilters().getFilterPart(EMPTY_ARRAY, true); + filter = new DefaultFilters().getIncludesFilterPart(EMPTY_ARRAY); advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY, - EMPTY_ARRAY, DEFAULT_INCLUDES, NOT_JAVA, "antDefaultFilter"), + EMPTY_ARRAY, DEFAULT_INCLUDES, FilterFileType.RESOURCE_FILES, "antDefaultFilter"), new ResourceFilterString(filter, "defaultFilter")); // everything should be excluded - filter = new DefaultFilters().getFilterPart(EMPTY_ARRAY, false); + filter = new DefaultFilters().getExcludesFilterPart(EMPTY_ARRAY); advancedPaths.testAdvancedPath(getAntFilter(new String[] {"a/1/2/3"}, - new String[] {"**", "/**"}, EMPTY_ARRAY, DEFAULT_INCLUDES, NOT_JAVA, + new String[] {"**", "/**"}, EMPTY_ARRAY, DEFAULT_INCLUDES, FilterFileType.RESOURCE_FILES, "antDefaultFilter"), new ResourceFilterString(filter, "defaultFilter")); - filter = new DefaultFilters().getFilterPart(mergedPatterns, true); - advancedPaths.testAdvancedPath(getAntFilter(mergedPatterns, EMPTY_ARRAY, - EMPTY_ARRAY, DEFAULT_INCLUDES, NOT_JAVA, "antMergedPatterns"), + filter = new DefaultFilters().getIncludesFilterPart(MERGED_PATTERNS); + advancedPaths.testAdvancedPath(getAntFilter(MERGED_PATTERNS, EMPTY_ARRAY, + EMPTY_ARRAY, DEFAULT_INCLUDES, FilterFileType.RESOURCE_FILES, "antMergedPatterns"), new ResourceFilterString(filter, "customMergedPatterns")); } @@ -309,25 +330,25 @@ ResourceFilter filter = null; // pass empty includeArray. Matches everything that is not excluded. - filter = getFilterWithoutCatchAll(EMPTY_ARRAY, mergedPatterns, EMPTY_ARRAY, - NOT_JAVA); - advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY, mergedPatterns, - EMPTY_ARRAY, DEFAULT_EXCLUDES, NOT_JAVA, "ant_emptyArray_mergedPatterns"), + filter = getFilterWithoutCatchAll(EMPTY_ARRAY, MERGED_PATTERNS, EMPTY_ARRAY, + FilterFileType.RESOURCE_FILES); + advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY, MERGED_PATTERNS, + EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, "ant_emptyArray_mergedPatterns"), new ResourceFilterString(filter, "custom_emptyArray_mergedPatterns")); // pass empty excludeArray. Matches everything that is included. - filter = getFilterWithoutCatchAll(mergedPatterns, EMPTY_ARRAY, EMPTY_ARRAY, - NOT_JAVA); - advancedPaths.testAdvancedPath(getAntFilter(mergedPatterns, EMPTY_ARRAY, - EMPTY_ARRAY, DEFAULT_EXCLUDES, NOT_JAVA, "ant_mergedPatterns_emptyArray"), + filter = getFilterWithoutCatchAll(MERGED_PATTERNS, EMPTY_ARRAY, EMPTY_ARRAY, + FilterFileType.RESOURCE_FILES); + advancedPaths.testAdvancedPath(getAntFilter(MERGED_PATTERNS, EMPTY_ARRAY, + EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, "ant_mergedPatterns_emptyArray"), new ResourceFilterString(filter, "custom_mergedPatterns_emptyArray")); // pass non-empty include and exclude array. Matches nothing - filter = getFilterWithoutCatchAll(mergedPatterns, mergedPatterns, - EMPTY_ARRAY, NOT_JAVA); + filter = getFilterWithoutCatchAll(MERGED_PATTERNS, MERGED_PATTERNS, + EMPTY_ARRAY, FilterFileType.RESOURCE_FILES); advancedPaths.testAdvancedPath( - getAntFilter(mergedPatterns, mergedPatterns, EMPTY_ARRAY, - DEFAULT_EXCLUDES, NOT_JAVA, "ant_mergedPatterns_mergedPatterns"), + getAntFilter(MERGED_PATTERNS, MERGED_PATTERNS, EMPTY_ARRAY, + DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, "ant_mergedPatterns_mergedPatterns"), new ResourceFilterString(filter, "custom_mergedPatterns_mergedPatterns")); } @@ -337,26 +358,26 @@ ResourceFilter filter = null; // pass empty includeArray. Matches everything that is not excluded. - filter = getFilterWithCatchAll(EMPTY_ARRAY, mergedPatterns, EMPTY_ARRAY, - NOT_JAVA); - advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY, mergedPatterns, - EMPTY_ARRAY, DEFAULT_EXCLUDES, NOT_JAVA, - "ant_emptyArray_mergedPatterns"), + filter = getFilterWithCatchAll(EMPTY_ARRAY, MERGED_PATTERNS, EMPTY_ARRAY, + FilterFileType.RESOURCE_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY, MERGED_PATTERNS, + EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, + "ant_emptyIncludeArray_mergedPatterns"), new ResourceFilterString(filter, "custom_emptyArray_mergedPatterns")); // pass empty excludeArray. Matches everything that is included. - filter = getFilterWithCatchAll(mergedPatterns, EMPTY_ARRAY, EMPTY_ARRAY, - NOT_JAVA); - advancedPaths.testAdvancedPathAnt(getAntFilter(mergedPatterns, EMPTY_ARRAY, - EMPTY_ARRAY, DEFAULT_EXCLUDES, NOT_JAVA, - "ant_emptyArray_mergedPatterns"), + filter = getFilterWithCatchAll(MERGED_PATTERNS, EMPTY_ARRAY, EMPTY_ARRAY, + FilterFileType.RESOURCE_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(MERGED_PATTERNS, EMPTY_ARRAY, + EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, + "ant_emptyExcludeArray_mergedPatterns"), new ResourceFilterString(filter, "custom_emptyArray_mergedPatterns")); // pass non-empty include and exclude array. Matches nothing - filter = getFilterWithCatchAll(mergedPatterns, mergedPatterns, EMPTY_ARRAY, - NOT_JAVA); - advancedPaths.testAdvancedPathAnt(getAntFilter(mergedPatterns, - mergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, NOT_JAVA, + filter = getFilterWithCatchAll(MERGED_PATTERNS, MERGED_PATTERNS, EMPTY_ARRAY, + FilterFileType.RESOURCE_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(MERGED_PATTERNS, + MERGED_PATTERNS, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, "ant_mergedPatterns_mergedPatterns"), new ResourceFilterString(filter, "custom_mergedPatterns_mergedPatterns")); } @@ -364,146 +385,240 @@ // no ant, catchAll filter is null public void testNonEmptyJavaFilters() { AdvancedPaths advancedPaths = new AdvancedPaths(); - - String newMergedPatterns[] = new String[mergedPatterns.length]; - for (int i = 0; i < mergedPatterns.length; i++) { - if (mergedPatterns[i].endsWith("*")) { - newMergedPatterns[i] = mergedPatterns[i]; - } else { - newMergedPatterns[i] = mergedPatterns[i] + ".java"; - } - } + String newMergedPatterns[] = getMergedPatterns(JAVA_FILE_SUFFIX); ResourceFilter filter = null; + // pass empty includeArray. Means catch all filter = getFilterWithoutCatchAll(EMPTY_ARRAY, newMergedPatterns, - EMPTY_ARRAY, YES_JAVA); - advancedPaths.testAdvancedJavaPath(getAntFilter(EMPTY_ARRAY, - newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, YES_JAVA, + EMPTY_ARRAY, FilterFileType.JAVA_FILES); + advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY, + newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter, - "custom_emptyArray_newMergedPatterns")); + "custom_emptyArray_newMergedPatterns"), JAVA_FILE_SUFFIX); // pass empty excludeArray. Means catch only the pattern filter = getFilterWithoutCatchAll(newMergedPatterns, EMPTY_ARRAY, - EMPTY_ARRAY, YES_JAVA); - advancedPaths.testAdvancedJavaPath(getAntFilter(newMergedPatterns, - EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, YES_JAVA, + EMPTY_ARRAY, FilterFileType.JAVA_FILES); + advancedPaths.testAdvancedPath(getAntFilter(newMergedPatterns, + EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_newMergedPatterns_emptyArray"), new ResourceFilterString(filter, - "custom_newMergedPatterns_emptyArray")); + "custom_newMergedPatterns_emptyArray"), JAVA_FILE_SUFFIX); // pass non-empty include and exclude array. filter = getFilterWithoutCatchAll(newMergedPatterns, newMergedPatterns, - EMPTY_ARRAY, YES_JAVA); - advancedPaths.testAdvancedJavaPath(getAntFilter(newMergedPatterns, - newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, YES_JAVA, + EMPTY_ARRAY, FilterFileType.JAVA_FILES); + advancedPaths.testAdvancedPath(getAntFilter(newMergedPatterns, + newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString( - filter, "custom_newMergedPatterns_newMergedPatterns")); + filter, "custom_newMergedPatterns_newMergedPatterns"), JAVA_FILE_SUFFIX); } public void testNonEmptyJavaFiltersAnt() { AdvancedPaths advancedPaths = new AdvancedPaths(); - - String newMergedPatterns[] = new String[mergedPatterns.length]; - for (int i = 0; i < mergedPatterns.length; i++) { - if (mergedPatterns[i].endsWith("*")) { - newMergedPatterns[i] = mergedPatterns[i]; - } else { - newMergedPatterns[i] = mergedPatterns[i] + ".java"; - } - } + String newMergedPatterns[] = getMergedPatterns(JAVA_FILE_SUFFIX); ResourceFilter filter = null; + // pass empty includeArray. Means catch all filter = getFilterWithCatchAll(EMPTY_ARRAY, newMergedPatterns, EMPTY_ARRAY, - YES_JAVA); - advancedPaths.testAdvancedJavaPathAnt(getAntFilter(EMPTY_ARRAY, - newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, YES_JAVA, + FilterFileType.JAVA_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY, + newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter, - "custom_emptyArray_newMergedPatterns")); + "custom_emptyArray_newMergedPatterns"), JAVA_FILE_SUFFIX); // pass empty excludeArray. Means catch only the pattern filter = getFilterWithCatchAll(newMergedPatterns, EMPTY_ARRAY, EMPTY_ARRAY, - YES_JAVA); - advancedPaths.testAdvancedJavaPathAnt(getAntFilter(newMergedPatterns, - EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, YES_JAVA, + FilterFileType.JAVA_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns, + EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_newMergedPatterns_emptyArray"), new ResourceFilterString(filter, - "custom_newMergedPatterns_emptyArray")); + "custom_newMergedPatterns_emptyArray"), JAVA_FILE_SUFFIX); // pass non-empty include and exclude array. filter = getFilterWithCatchAll(newMergedPatterns, newMergedPatterns, - EMPTY_ARRAY, YES_JAVA); - advancedPaths.testAdvancedJavaPathAnt(getAntFilter(newMergedPatterns, - newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, YES_JAVA, + EMPTY_ARRAY, FilterFileType.JAVA_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns, + newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString( - filter, "custom_newMergedPatterns_newMergedPatterns")); + filter, "custom_newMergedPatterns_newMergedPatterns"), JAVA_FILE_SUFFIX); } public void testNonEmptyJavaSkipFiltersAnt() { AdvancedPaths advancedPaths = new AdvancedPaths(); - - String newMergedPatterns[] = new String[mergedPatterns.length]; - for (int i = 0; i < mergedPatterns.length; i++) { - if (mergedPatterns[i].endsWith("*")) { - newMergedPatterns[i] = mergedPatterns[i]; - } else { - newMergedPatterns[i] = mergedPatterns[i] + ".java"; - } - } + String newMergedPatterns[] = getMergedPatterns(JAVA_FILE_SUFFIX); ResourceFilter filter = null; // pass empty includeArray. Means catch all, skipping newMergedPatterns filter = getFilterWithCatchAll(EMPTY_ARRAY, EMPTY_ARRAY, newMergedPatterns, - YES_JAVA); + FilterFileType.JAVA_FILES); advancedPaths.testAdvancedJavaPathAnt(getAntFilter(EMPTY_ARRAY, - EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, YES_JAVA, + EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter, "custom_emptyArray_newMergedPatterns")); // pass non-empty include and skip array. filter = getFilterWithCatchAll(newMergedPatterns, EMPTY_ARRAY, - newMergedPatterns, YES_JAVA); + newMergedPatterns, FilterFileType.JAVA_FILES); advancedPaths.testAdvancedJavaPathAnt(getAntFilter(newMergedPatterns, - EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, YES_JAVA, + EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString( filter, "custom_newMergedPatterns_newMergedPatterns")); // in a single filter, skip and exclude are equivalent filter = getFilterWithCatchAll(newMergedPatterns, newMergedPatterns, - EMPTY_ARRAY, YES_JAVA); + EMPTY_ARRAY, FilterFileType.JAVA_FILES); advancedPaths.testAdvancedJavaPathAnt(getAntFilter(newMergedPatterns, - EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, YES_JAVA, + EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES, "ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString( filter, "custom_newMergedPatterns_newMergedPatterns")); } + + // no ant, catchAll filter is null + public void testNonEmptyClassFileFilters() { + AdvancedPaths advancedPaths = new AdvancedPaths(); + String newMergedPatterns[] = getMergedPatterns(CLASS_FILE_SUFFIX); + ResourceFilter filter = null; + // pass empty includeArray. Means catch all + filter = getFilterWithoutCatchAll(EMPTY_ARRAY, newMergedPatterns, + EMPTY_ARRAY, FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY, + newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter, + "custom_emptyArray_newMergedPatterns"), CLASS_FILE_SUFFIX); + + // pass empty excludeArray. Means catch only the pattern + filter = getFilterWithoutCatchAll(newMergedPatterns, EMPTY_ARRAY, + EMPTY_ARRAY, FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPath(getAntFilter(newMergedPatterns, + EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_newMergedPatterns_emptyArray"), new ResourceFilterString(filter, + "custom_newMergedPatterns_emptyArray"), CLASS_FILE_SUFFIX); + + // pass non-empty include and exclude array. + filter = getFilterWithoutCatchAll(newMergedPatterns, newMergedPatterns, + EMPTY_ARRAY, FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPath(getAntFilter(newMergedPatterns, + newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString( + filter, "custom_newMergedPatterns_newMergedPatterns"), CLASS_FILE_SUFFIX); + } + + public void testNonEmptyClassFileFiltersAnt() { + AdvancedPaths advancedPaths = new AdvancedPaths(); + String newMergedPatterns[] = getMergedPatterns(CLASS_FILE_SUFFIX); + ResourceFilter filter = null; + + // pass empty includeArray. Means catch all + filter = getFilterWithCatchAll(EMPTY_ARRAY, newMergedPatterns, EMPTY_ARRAY, + FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY, + newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter, + "custom_emptyArray_newMergedPatterns"), CLASS_FILE_SUFFIX); + + // pass empty excludeArray. Means catch only the pattern + filter = getFilterWithCatchAll(newMergedPatterns, EMPTY_ARRAY, EMPTY_ARRAY, + FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns, + EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_newMergedPatterns_emptyArray"), new ResourceFilterString(filter, + "custom_newMergedPatterns_emptyArray"), CLASS_FILE_SUFFIX); + + // pass non-empty include and exclude array. + filter = getFilterWithCatchAll(newMergedPatterns, newMergedPatterns, + EMPTY_ARRAY, FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns, + newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString( + filter, "custom_newMergedPatterns_newMergedPatterns"), CLASS_FILE_SUFFIX); + } + + private String[] getMergedPatterns(String suffix) { + String newMergedPatterns[] = new String[MERGED_PATTERNS.length]; + for (int i = 0; i < MERGED_PATTERNS.length; i++) { + if (MERGED_PATTERNS[i].endsWith("*")) { + newMergedPatterns[i] = MERGED_PATTERNS[i]; + } else { + newMergedPatterns[i] = MERGED_PATTERNS[i] + suffix; + } + } + return newMergedPatterns; + } + + public void testNonEmptyClassFileSkipFiltersAnt() { + AdvancedPaths advancedPaths = new AdvancedPaths(); + String newMergedPatterns[] = getMergedPatterns(CLASS_FILE_SUFFIX); + ResourceFilter filter = null; + + // pass empty includeArray. Means catch all, skipping newMergedPatterns + filter = getFilterWithCatchAll(EMPTY_ARRAY, EMPTY_ARRAY, newMergedPatterns, + FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY, + EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter, + "custom_emptyArray_newMergedPatterns"), CLASS_FILE_SUFFIX); + + // pass non-empty include and skip array. + filter = getFilterWithCatchAll(newMergedPatterns, EMPTY_ARRAY, + newMergedPatterns, FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns, + EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString( + filter, "custom_newMergedPatterns_newMergedPatterns"), CLASS_FILE_SUFFIX); + + // in a single filter, skip and exclude are equivalent + filter = getFilterWithCatchAll(newMergedPatterns, newMergedPatterns, + EMPTY_ARRAY, FilterFileType.CLASS_FILES); + advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns, + EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, + "ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString( + filter, "custom_newMergedPatterns_newMergedPatterns"), CLASS_FILE_SUFFIX); + } + private ResourceFilterString getAntFilter(String includes[], String excludes[], String skips[], boolean defaultExcludes, - final boolean isJava, String tag) { + final FilterFileType filterFileType, String tag) { final ZipScanner scanner = DefaultFilters.getScanner(includes, excludes, skips, defaultExcludes, true); return new ResourceFilterString(new ResourceFilter() { public boolean allows(String path) { - if (isJava && !path.endsWith(".java")) { - return false; - } - return scanner.match(path); + return fileTypeMatches(filterFileType, path) && scanner.match(path); } }, tag != null ? tag : "includes: " + Arrays.toString(includes) + ", excludes: " + Arrays.toString(excludes)); } private ResourceFilter getFilterWithCatchAll(String includesList[], - String excludesList[], String skipList[], boolean isJava) { - if (isJava) { - return new DefaultFilters().customJavaFilter(includesList, excludesList, - skipList, true, true); + String excludesList[], String skipList[], FilterFileType filterFileType) { + switch (filterFileType) { + case JAVA_FILES: + return new DefaultFilters().customJavaFilter(includesList, excludesList, + skipList, true, true); + case CLASS_FILES: + return new DefaultFilters().customClassFilesFilter(includesList, excludesList, + skipList, true, true); + case RESOURCE_FILES: + default: + return new DefaultFilters().customResourceFilter(includesList, + excludesList, skipList, true, true); } - return new DefaultFilters().customResourceFilter(includesList, - excludesList, skipList, true, true); } // caseSensitive and excludeDefaults are set private ResourceFilter getFilterWithoutCatchAll(String includesList[], - String excludesList[], String skipList[], boolean isJava) { + String excludesList[], String skipList[], FilterFileType filterFileType) { return new DefaultFilters().customFilterWithCatchAll(includesList, - excludesList, skipList, true, null, isJava); + excludesList, skipList, true, null, filterFileType); + } + + private boolean fileTypeMatches(FilterFileType filterFileType, String path) { + switch (filterFileType) { + case JAVA_FILES: + return path.endsWith(".java"); + case CLASS_FILES: + return path.endsWith(".class"); + } + return true; } }