*/
package org.sonar.batch.scan.filesystem;
-import org.sonar.api.scan.filesystem.InputFile;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.BatchComponent;
-import org.sonar.api.batch.ResourceFilter;
-import org.sonar.api.resources.Resource;
-import org.sonar.api.resources.ResourceUtils;
import org.sonar.api.scan.filesystem.FileExclusions;
-import org.sonar.api.scan.filesystem.internal.InputFileFilter;
+import org.sonar.api.scan.filesystem.InputFile;
+import org.sonar.api.scan.filesystem.ModuleFileSystem;
+import org.sonar.api.scan.filesystem.PathResolver;
-public class ExclusionFilters implements InputFileFilter, ResourceFilter, BatchComponent {
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExclusionFilters implements BatchComponent {
private final FileExclusions exclusionSettings;
public ExclusionFilters(FileExclusions exclusions) {
this.exclusionSettings = exclusions;
}
- public void start() {
- log("Included sources: ", sourceInclusions());
+ public void logConfiguration(ModuleFileSystem fs) {
+ log("Included sources: ", sourceInclusions(fs));
log("Excluded sources: ", sourceExclusions());
- log("Included tests: ", testInclusions());
+ log("Included tests: ", testInclusions(fs));
log("Excluded tests: ", testExclusions());
}
}
}
- @Override
- public boolean accept(InputFile inputFile) {
+ public boolean accept(InputFile inputFile, ModuleFileSystem fs) {
String type = inputFile.attribute(InputFile.ATTRIBUTE_TYPE);
PathPattern[] inclusionPatterns = null;
PathPattern[] exclusionPatterns = null;
if (InputFile.TYPE_MAIN.equals(type)) {
- inclusionPatterns = sourceInclusions();
+ inclusionPatterns = sourceInclusions(fs);
exclusionPatterns = sourceExclusions();
} else if (InputFile.TYPE_TEST.equals(type)) {
- inclusionPatterns = testInclusions();
+ inclusionPatterns = testInclusions(fs);
exclusionPatterns = testExclusions();
}
+ boolean matchInclusion = false;
if (inclusionPatterns != null && inclusionPatterns.length > 0) {
- boolean matchInclusion = false;
for (PathPattern pattern : inclusionPatterns) {
matchInclusion |= pattern.match(inputFile);
}
}
}
}
- return true;
+ return matchInclusion;
}
-
- public boolean isIgnored(Resource resource) {
- if (ResourceUtils.isFile(resource)) {
- PathPattern[] inclusionPatterns = ResourceUtils.isUnitTestClass(resource) ? testInclusions() : sourceInclusions();
- if (isIgnoredByInclusions(resource, inclusionPatterns)) {
- return true;
- }
- PathPattern[] exclusionPatterns = ResourceUtils.isUnitTestClass(resource) ? testExclusions() : sourceExclusions();
- return isIgnoredByExclusions(resource, exclusionPatterns);
+ PathPattern[] sourceInclusions(ModuleFileSystem fs) {
+ if (exclusionSettings.sourceInclusions().length > 0) {
+ // User defined params
+ return PathPattern.create(exclusionSettings.sourceInclusions());
}
- return false;
- }
-
- private boolean isIgnoredByInclusions(Resource resource, PathPattern[] inclusionPatterns) {
- if (inclusionPatterns.length > 0) {
- boolean matchInclusion = false;
- boolean supportResource = false;
- for (PathPattern pattern : inclusionPatterns) {
- if (pattern.supportResource()) {
- supportResource = true;
- matchInclusion |= pattern.match(resource);
- }
- }
- if (supportResource && !matchInclusion) {
- return true;
- }
+ // Convert source directories to inclusions
+ List<String> sourcePattern = new ArrayList<String>();
+ for (File src : fs.sourceDirs()) {
+ String path = new PathResolver().relativePath(fs.baseDir(), src);
+ sourcePattern.add(path + "/**/*");
}
- return false;
+ return PathPattern.create(sourcePattern.toArray(new String[sourcePattern.size()]));
}
- private boolean isIgnoredByExclusions(Resource resource, PathPattern[] exclusionPatterns) {
- for (PathPattern pattern : exclusionPatterns) {
- if (pattern.supportResource() && pattern.match(resource)) {
- return true;
- }
+ PathPattern[] testInclusions(ModuleFileSystem fs) {
+ if (exclusionSettings.testInclusions().length > 0) {
+ // User defined params
+ return PathPattern.create(exclusionSettings.testInclusions());
}
- return false;
- }
-
- PathPattern[] sourceInclusions() {
- return PathPattern.create(exclusionSettings.sourceInclusions());
- }
-
- PathPattern[] testInclusions() {
- return PathPattern.create(exclusionSettings.testInclusions());
+ // Convert source directories to inclusions
+ List<String> testPatterns = new ArrayList<String>();
+ for (File test : fs.testDirs()) {
+ String path = new PathResolver().relativePath(fs.baseDir(), test);
+ testPatterns.add(path + "/**/*");
+ }
+ return PathPattern.create(testPatterns.toArray(new String[testPatterns.size()]));
}
PathPattern[] sourceExclusions() {
import org.sonar.api.scan.filesystem.internal.DefaultInputFile;
import org.sonar.api.scan.filesystem.internal.InputFileFilter;
import org.sonar.api.utils.PathUtils;
+import org.sonar.api.utils.SonarException;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import java.io.File;
import java.nio.charset.Charset;
import java.util.Collection;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class FileIndex implements BatchComponent {
private static class Progress {
- private int count = 0;
private final Set<String> removedPaths;
+ private final Set<String> indexed;
Progress(Set<String> removedPaths) {
this.removedPaths = removedPaths;
+ this.indexed = new HashSet<String>();
}
void markAsIndexed(String relativePath) {
- count++;
+ if (indexed.contains(relativePath)) {
+ throw new SonarException("File " + relativePath + " can't be indexed twice. Please check that inclusion/exclusion patterns produce "
+ + "disjoint sets for main and test files");
+ }
removedPaths.remove(relativePath);
+ indexed.add(relativePath);
+ }
+
+ int count() {
+ return indexed.size();
}
}
private final InputFileCache fileCache;
private final FileHashes fileHashes;
private final Project project;
+ private final ExclusionFilters exclusionFilters;
- public FileIndex(List<InputFileFilter> filters, LanguageRecognizer languageRecognizer,
+ public FileIndex(List<InputFileFilter> filters, ExclusionFilters exclusionFilters, LanguageRecognizer languageRecognizer,
InputFileCache cache, FileHashes fileHashes, PathResolver pathResolver, Project project) {
this.filters = filters;
+ this.exclusionFilters = exclusionFilters;
this.languageRecognizer = languageRecognizer;
this.fileCache = cache;
this.fileHashes = fileHashes;
void index(DefaultModuleFileSystem fileSystem) {
Logger logger = LoggerFactory.getLogger(FileIndex.class);
logger.info("Index files");
+ exclusionFilters.logConfiguration(fileSystem);
// TODO log configuration too (replace FileSystemLogger)
Progress progress = new Progress(fileCache.fileRelativePaths(fileSystem.moduleKey()));
- if (fileSystem.sourceFiles().isEmpty()) {
- // index directories
- for (File sourceDir : fileSystem.sourceDirs()) {
- indexDirectory(fileSystem, progress, sourceDir, InputFile.TYPE_MAIN);
- }
- } else {
- // index only given files
- indexFiles(fileSystem, progress, fileSystem.sourceDirs(), fileSystem.sourceFiles(), InputFile.TYPE_MAIN);
- }
-
- if (fileSystem.testFiles().isEmpty()) {
- // index directories
- for (File testDir : fileSystem.testDirs()) {
- indexDirectory(fileSystem, progress, testDir, InputFile.TYPE_TEST);
- }
+ if (!fileSystem.sourceFiles().isEmpty() || !fileSystem.testFiles().isEmpty()) {
+ // Index only provided files
+ indexFiles(fileSystem, progress, fileSystem.sourceFiles(), InputFile.TYPE_MAIN);
+ indexFiles(fileSystem, progress, fileSystem.testFiles(), InputFile.TYPE_TEST);
} else {
- // index only given files
- indexFiles(fileSystem, progress, fileSystem.testDirs(), fileSystem.testFiles(), InputFile.TYPE_TEST);
+ // index from basedir
+ indexDirectory(fileSystem, progress, fileSystem.baseDir(), InputFile.TYPE_MAIN);
+ indexDirectory(fileSystem, progress, fileSystem.baseDir(), InputFile.TYPE_TEST);
}
// Remove files that have been removed since previous indexation
fileCache.remove(fileSystem.moduleKey(), path);
}
- logger.info(String.format("%d files indexed", progress.count));
+ logger.info(String.format("%d files indexed", progress.count()));
}
- private void indexFiles(DefaultModuleFileSystem fileSystem, Progress progress, List<File> sourceDirs, List<File> sourceFiles, String type) {
+ private void indexFiles(DefaultModuleFileSystem fileSystem, Progress progress, List<File> sourceFiles, String type) {
for (File sourceFile : sourceFiles) {
- PathResolver.RelativePath sourceDirPath = pathResolver.relativePath(sourceDirs, sourceFile);
- if (sourceDirPath == null) {
+ String path = pathResolver.relativePath(fileSystem.baseDir(), sourceFile);
+ if (path == null) {
LoggerFactory.getLogger(getClass()).warn(String.format(
- "File '%s' is not declared in source directories %s", sourceFile.getAbsoluteFile(), StringUtils.join(sourceDirs, ", ")
+ "File '%s' is not declared in module basedir %s", sourceFile.getAbsoluteFile(), fileSystem.baseDir()
));
} else {
- indexFile(fileSystem, progress, sourceDirPath.dir(), sourceFile, type);
+ indexFile(fileSystem, progress, sourceFile, type);
}
}
}
return DefaultInputDir.create(ioFile, path, attributes);
}
- private void indexDirectory(DefaultModuleFileSystem fileSystem, Progress status, File sourceDir, String type) {
- Collection<File> files = FileUtils.listFiles(sourceDir, FILE_FILTER, DIR_FILTER);
+ private void indexDirectory(DefaultModuleFileSystem fileSystem, Progress status, File dirToIndex, String type) {
+ Collection<File> files = FileUtils.listFiles(dirToIndex, FILE_FILTER, DIR_FILTER);
for (File file : files) {
- indexFile(fileSystem, status, sourceDir, file, type);
+ indexFile(fileSystem, status, file, type);
}
}
- private void indexFile(DefaultModuleFileSystem fileSystem, Progress status, File sourceDir, File file, String type) {
+ private void indexFile(DefaultModuleFileSystem fileSystem, Progress status, File file, String type) {
String path = computeFilePath(fileSystem, file);
if (path == null) {
LoggerFactory.getLogger(getClass()).warn(String.format("File '%s' is not in basedir '%s'", file.getAbsolutePath(), fileSystem.baseDir()));
} else {
- InputFile input = newInputFile(fileSystem, sourceDir, type, file, path);
- if (input != null && accept(input)) {
+ InputFile input = newInputFile(fileSystem, type, file, path);
+ if (input != null && accept(input, fileSystem)) {
fileCache.put(fileSystem.moduleKey(), input);
status.markAsIndexed(path);
}
}
@CheckForNull
- private InputFile newInputFile(ModuleFileSystem fileSystem, File sourceDir, String type, File file, String path) {
+ private InputFile newInputFile(ModuleFileSystem fileSystem, String type, File file, String path) {
Map<String, String> attributes = Maps.newHashMap();
set(attributes, InputFile.ATTRIBUTE_TYPE, type);
- // paths
- set(attributes, DefaultInputFile.ATTRIBUTE_SOURCEDIR_PATH, PathUtils.canonicalPath(sourceDir));
- String sourceRelativePath = pathResolver.relativePath(sourceDir, file);
- set(attributes, DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, sourceRelativePath);
-
String resourceKey = PathUtils.sanitize(path);
set(attributes, DefaultInputFile.ATTRIBUTE_COMPONENT_KEY, project.getEffectiveKey() + ":" + resourceKey);
// hash + status
return null;
}
set(inputFile.attributes(), InputFile.ATTRIBUTE_LANGUAGE, lang);
- if (Java.KEY.equals(lang)) {
- set(inputFile.attributes(), DefaultInputFile.ATTRIBUTE_COMPONENT_DEPRECATED_KEY, project.getEffectiveKey() + ":"
- + JavaFile.fromRelativePath(sourceRelativePath, false).getDeprecatedKey());
- } else {
- set(inputFile.attributes(), DefaultInputFile.ATTRIBUTE_COMPONENT_DEPRECATED_KEY, project.getEffectiveKey() + ":" + sourceRelativePath);
- }
+
+ setDeprecatedAttributes(fileSystem, type, file, attributes, inputFile, lang);
+
return inputFile;
}
+ private void setDeprecatedAttributes(ModuleFileSystem fileSystem, String type, File file, Map<String, String> attributes, DefaultInputFile inputFile, String lang) {
+ List<File> sourceDirs = InputFile.TYPE_MAIN.equals(type) ? fileSystem.sourceDirs() : fileSystem.testDirs();
+ for (File src : sourceDirs) {
+ String sourceRelativePath = pathResolver.relativePath(src, file);
+ if (sourceRelativePath != null) {
+ set(attributes, DefaultInputFile.ATTRIBUTE_SOURCEDIR_PATH, PathUtils.canonicalPath(src));
+ set(attributes, DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, sourceRelativePath);
+ if (Java.KEY.equals(lang)) {
+ set(inputFile.attributes(), DefaultInputFile.ATTRIBUTE_COMPONENT_DEPRECATED_KEY, project.getEffectiveKey() + ":"
+ + JavaFile.fromRelativePath(sourceRelativePath, false).getDeprecatedKey());
+ } else {
+ set(inputFile.attributes(), DefaultInputFile.ATTRIBUTE_COMPONENT_DEPRECATED_KEY, project.getEffectiveKey() + ":" + sourceRelativePath);
+ }
+ return;
+ }
+ }
+ }
+
private void initStatus(File file, Charset charset, String baseRelativePath, Map<String, String> attributes) {
String hash = fileHashes.hash(file, charset);
set(attributes, DefaultInputFile.ATTRIBUTE_HASH, hash);
}
}
- private boolean accept(InputFile inputFile) {
+ private boolean accept(InputFile inputFile, ModuleFileSystem fs) {
+ if (!exclusionFilters.accept(inputFile, fs)) {
+ return false;
+ }
+ // Other InputFileFilter extensions
for (InputFileFilter filter : filters) {
if (!filter.accept(inputFile)) {
return false;
*/
package org.sonar.batch.scan.filesystem;
-import org.sonar.api.scan.filesystem.InputFile;
-
import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableMap;
+import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.sonar.api.CoreProperties;
import org.sonar.api.config.Settings;
-import org.sonar.api.resources.File;
-import org.sonar.api.resources.JavaFile;
-import org.sonar.api.resources.Project;
import org.sonar.api.scan.filesystem.FileExclusions;
+import org.sonar.api.scan.filesystem.InputFile;
+import org.sonar.api.scan.filesystem.ModuleFileSystem;
import org.sonar.api.scan.filesystem.internal.DefaultInputFile;
+import java.io.File;
import java.io.IOException;
+import java.util.Arrays;
import static org.fest.assertions.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
public class ExclusionFiltersTest {
@Rule
public TemporaryFolder temp = new TemporaryFolder();
+ private ModuleFileSystem fs;
+ private File basedir;
+
+ @Before
+ public void prepare() throws IOException {
+ basedir = temp.newFolder();
+ fs = mock(ModuleFileSystem.class);
+ when(fs.baseDir()).thenReturn(basedir);
+ }
@Test
public void should_match_source_inclusion() throws IOException {
java.io.File file = temp.newFile();
InputFile inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN,
- DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, "com/mycompany/Foo.java"
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
));
- assertThat(filter.accept(inputFile)).isFalse();
+ assertThat(filter.accept(inputFile, fs)).isFalse();
inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/FooDao.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN,
- DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, "com/mycompany/FooDao.java"
- ));
- assertThat(filter.accept(inputFile)).isTrue();
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN));
+ assertThat(filter.accept(inputFile, fs)).isTrue();
- // source inclusions do not apply to tests
+ // test are excluded by default if no sonar.tests nor sonar.test.inclusions
inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST,
- DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, "com/mycompany/Foo.java"
- ));
- assertThat(filter.accept(inputFile)).isTrue();
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST));
+ assertThat(filter.accept(inputFile, fs)).isFalse();
}
@Test
- public void should_match_at_least_one_source_inclusion() throws IOException {
+ public void should_include_source_folders_by_default() throws IOException {
Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "**/*Dao.java,**/*Dto.java");
ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
+ when(fs.sourceDirs()).thenReturn(Arrays.asList(new File(basedir, "src/main/java")));
+
+ filter.logConfiguration(fs);
java.io.File file = temp.newFile();
InputFile inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN,
- DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, "com/mycompany/Foo.java"
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
));
- assertThat(filter.accept(inputFile)).isFalse();
+ assertThat(filter.accept(inputFile, fs)).isTrue();
- inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/FooDto.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN,
- DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, "com/mycompany/FooDto.java"
- ));
- assertThat(filter.accept(inputFile)).isTrue();
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java2/com/mycompany/FooDao.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN));
+ assertThat(filter.accept(inputFile, fs)).isFalse();
+
+ // source inclusions do not apply to tests
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST));
+ assertThat(filter.accept(inputFile, fs)).isFalse();
}
@Test
- public void should_match_source_exclusions() throws IOException {
+ public void should_include_source_and_test_folders_by_default() throws IOException {
Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/*Dao.java");
ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
+ when(fs.sourceDirs()).thenReturn(Arrays.asList(new File(basedir, "src/main/java")));
+ when(fs.testDirs()).thenReturn(Arrays.asList(new File(basedir, "src/test/java")));
+
+ filter.logConfiguration(fs);
java.io.File file = temp.newFile();
- InputFile inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/FooDao.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN,
- DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, "com/mycompany/FooDao.java"
+ InputFile inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
));
- assertThat(filter.accept(inputFile)).isFalse();
+
+ assertThat(filter.accept(inputFile, fs)).isTrue();
inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN,
- DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, "com/mycompany/Foo.java"
- ));
- assertThat(filter.accept(inputFile)).isTrue();
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST));
+ assertThat(filter.accept(inputFile, fs)).isFalse();
- // source exclusions do not apply to tests
- inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/FooDao.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST,
- DefaultInputFile.ATTRIBUTE_SOURCE_RELATIVE_PATH, "com/mycompany/FooDao.java"
- ));
- assertThat(filter.accept(inputFile)).isTrue();
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/test/java/com/mycompany/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST));
+ assertThat(filter.accept(inputFile, fs)).isTrue();
}
@Test
- public void should_match_source_exclusion_by_absolute_path() throws IOException {
- java.io.File includedFile = temp.newFile("Foo.java");
- java.io.File excludedFile = temp.newFile("Bar.java");
-
+ public void should_ignore_source_folders_if_inclusion_defined() throws IOException {
Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "file:" + excludedFile.getCanonicalPath());
+ settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "src/main/java2/**/*");
ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
+ when(fs.sourceDirs()).thenReturn(Arrays.asList(new File(basedir, "src/main/java")));
- InputFile includedInput = DefaultInputFile.create(includedFile, Charsets.UTF_8, "src/main/java/org/bar/Foo.java", ImmutableMap.of(
- InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
- ));
- assertThat(filter.accept(includedInput)).isTrue();
+ filter.logConfiguration(fs);
- InputFile excludedInput = DefaultInputFile.create(excludedFile, Charsets.UTF_8, "src/main/java/org/bar/Bar.java", ImmutableMap.of(
+ java.io.File file = temp.newFile();
+ InputFile inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
));
- assertThat(filter.accept(excludedInput)).isFalse();
- }
- @Test
- public void should_match_resource_inclusions() throws IOException {
- Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "**/*Dao.c");
- ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
+ assertThat(filter.accept(inputFile, fs)).isFalse();
+
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java2/com/mycompany/FooDao.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN));
+ assertThat(filter.accept(inputFile, fs)).isTrue();
- assertThat(filter.isIgnored(File.create("src/org/sonar/FooDao.c", "org/sonar/FooDao.c", null, false))).isFalse();
- assertThat(filter.isIgnored(File.create("src/org/sonar/Foo.c", "org/sonar/Foo.c", null, false))).isTrue();
+ // source inclusions do not apply to tests
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST));
+ assertThat(filter.accept(inputFile, fs)).isFalse();
}
@Test
- public void should_match_resource_exclusions() throws IOException {
+ public void should_include_test_folders_by_default() throws IOException {
Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/*Dao.c");
ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
+ when(fs.testDirs()).thenReturn(Arrays.asList(new File(basedir, "src/test/java")));
- assertThat(filter.isIgnored(File.create("src/org/sonar/FooDao.c", "org/sonar/FooDao.c", null, false))).isTrue();
- assertThat(filter.isIgnored(File.create("src/org/sonar/Foo.c", "org/sonar/Foo.c", null, false))).isFalse();
- }
+ filter.logConfiguration(fs);
- @Test
- public void should_ignore_resource_exclusions_by_absolute_path() throws IOException {
- Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "file:**/*Dao.c");
- ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
+ java.io.File file = temp.newFile();
+ InputFile inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/test/java/com/mycompany/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
+ ));
- assertThat(filter.isIgnored(File.create("src/org/sonar/FooDao.c", "org/sonar/FooDao.c", null, false))).isFalse();
- assertThat(filter.isIgnored(File.create("src/org/sonar/Foo.c", "org/sonar/Foo.c", null, false))).isFalse();
- }
+ // test inclusions do not apply to main code
+ assertThat(filter.accept(inputFile, fs)).isFalse();
- @Test
- public void should_ignore_resource_inclusions_by_absolute_path() throws IOException {
- Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "file:**/*Dao.c");
- ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/test2/java/com/mycompany/FooTest.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST));
+ assertThat(filter.accept(inputFile, fs)).isFalse();
- assertThat(filter.isIgnored(File.create("src/org/sonar/FooDao.c", "org/sonar/FooDao.c", null, false))).isFalse();
- assertThat(filter.isIgnored(File.create("src/org/sonar/Foo.c", "org/sonar/Foo.c", null, false))).isFalse();
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/test/java/com/mycompany/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST));
+ assertThat(filter.accept(inputFile, fs)).isTrue();
}
- /**
- * JavaFile will be deprecated
- */
@Test
- public void should_match_java_resource_inclusions() throws IOException {
+ public void should_match_at_least_one_source_inclusion() throws IOException {
Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "**/*Dao.java");
+ settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "**/*Dao.java,**/*Dto.java");
ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
- assertThat(filter.isIgnored(JavaFile.create("src/org/sonar/FooDao.java", "org/sonar/FooDao.java", false))).isFalse();
- assertThat(filter.isIgnored(JavaFile.create("src/org/sonar/Foo.java", "org/sonar/Foo.java", false))).isTrue();
+ java.io.File file = temp.newFile();
+ InputFile inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
+ ));
+
+ assertThat(filter.accept(inputFile, fs)).isFalse();
+
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/FooDto.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
+ ));
+ assertThat(filter.accept(inputFile, fs)).isTrue();
}
- /**
- * JavaFile will be deprecated
- */
@Test
- public void should_match_java_resource_exclusions() throws IOException {
+ public void should_match_source_exclusions() throws IOException {
Settings settings = new Settings();
+ settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "src/main/java/**/*");
+ settings.setProperty(CoreProperties.PROJECT_TEST_INCLUSIONS_PROPERTY, "src/test/java/**/*");
settings.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/*Dao.java");
ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
- assertThat(filter.isIgnored(JavaFile.create("src/org/sonar/FooDao.java", "org/sonar/FooDao.java", false))).isTrue();
- assertThat(filter.isIgnored(JavaFile.create("src/org/sonar/Foo.java", "org/sonar/Foo.java", false))).isFalse();
- }
+ java.io.File file = temp.newFile();
+ InputFile inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/FooDao.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
+ ));
+ assertThat(filter.accept(inputFile, fs)).isFalse();
- @Test
- public void should_not_check_exclusions_on_non_file_resources() throws IOException {
- Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "*");
- ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/main/java/com/mycompany/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN));
+ assertThat(filter.accept(inputFile, fs)).isTrue();
- assertThat(filter.isIgnored(new Project("MyProject"))).isFalse();
+ // source exclusions do not apply to tests
+ inputFile = DefaultInputFile.create(file, Charsets.UTF_8, "src/test/java/com/mycompany/FooDao.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_TEST));
+ assertThat(filter.accept(inputFile, fs)).isTrue();
}
@Test
- public void test_settings() throws IOException {
+ public void should_match_source_exclusion_by_absolute_path() throws IOException {
+ java.io.File includedFile = temp.newFile("Foo.java");
+ java.io.File excludedFile = temp.newFile("Bar.java");
+
Settings settings = new Settings();
- settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "source/inclusions");
- settings.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "source/exclusions");
- settings.setProperty(CoreProperties.PROJECT_TEST_INCLUSIONS_PROPERTY, "test/inclusions");
- settings.setProperty(CoreProperties.PROJECT_TEST_EXCLUSIONS_PROPERTY, "test/exclusions");
+ settings.setProperty(CoreProperties.PROJECT_INCLUSIONS_PROPERTY, "src/main/java/**/*");
+ settings.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "file:" + excludedFile.getCanonicalPath());
ExclusionFilters filter = new ExclusionFilters(new FileExclusions(settings));
- assertThat(filter.sourceInclusions()[0].toString()).isEqualTo("source/inclusions");
- assertThat(filter.testInclusions()[0].toString()).isEqualTo("test/inclusions");
- assertThat(filter.sourceExclusions()[0].toString()).isEqualTo("source/exclusions");
- assertThat(filter.testExclusions()[0].toString()).isEqualTo("test/exclusions");
+ InputFile includedInput = DefaultInputFile.create(includedFile, Charsets.UTF_8, "src/main/java/org/bar/Foo.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
+ ));
+ assertThat(filter.accept(includedInput, fs)).isTrue();
+
+ InputFile excludedInput = DefaultInputFile.create(excludedFile, Charsets.UTF_8, "src/main/java/org/bar/Bar.java", ImmutableMap.of(
+ InputFile.ATTRIBUTE_TYPE, InputFile.TYPE_MAIN
+ ));
+ assertThat(filter.accept(excludedInput, fs)).isFalse();
}
@Test
projects / sonarqube.git / commitdiff