import org.sonar.batch.events.EventBus;
import org.sonar.batch.index.DefaultIndex;
import org.sonar.batch.index.PersistenceManager;
+import org.sonar.batch.scan.filesystem.FileSystemLogger;
import org.sonar.batch.scan.maven.MavenPhaseExecutor;
import org.sonar.batch.scan.maven.MavenPluginsConfigurator;
import org.sonar.core.component.ScanGraphStore;
private DefaultIndex index;
private ProjectInitializer pi;
private ScanGraphStore graphStorage;
+ private FileSystemLogger fsLogger;
public Phases(DecoratorsExecutor decoratorsExecutor, MavenPhaseExecutor mavenPhaseExecutor,
MavenPluginsConfigurator mavenPluginsConfigurator, InitializersExecutor initializersExecutor,
PostJobsExecutor postJobsExecutor, SensorsExecutor sensorsExecutor,
PersistenceManager persistenceManager, SensorContext sensorContext, DefaultIndex index,
EventBus eventBus, UpdateStatusJob updateStatusJob, ProjectInitializer pi,
- ScanGraphStore graphStorage) {
+ ScanGraphStore graphStorage, FileSystemLogger fsLogger) {
this.decoratorsExecutor = decoratorsExecutor;
this.mavenPhaseExecutor = mavenPhaseExecutor;
this.mavenPluginsConfigurator = mavenPluginsConfigurator;
this.updateStatusJob = updateStatusJob;
this.pi = pi;
this.graphStorage = graphStorage;
+ this.fsLogger = fsLogger;
}
public Phases(DecoratorsExecutor decoratorsExecutor, MavenPhaseExecutor mavenPhaseExecutor,
MavenPluginsConfigurator mavenPluginsConfigurator, InitializersExecutor initializersExecutor,
PostJobsExecutor postJobsExecutor, SensorsExecutor sensorsExecutor,
PersistenceManager persistenceManager, SensorContext sensorContext, DefaultIndex index,
- EventBus eventBus, ProjectInitializer pi, ScanGraphStore graphStorage) {
+ EventBus eventBus, ProjectInitializer pi, ScanGraphStore graphStorage, FileSystemLogger fsLogger) {
this(decoratorsExecutor, mavenPhaseExecutor, mavenPluginsConfigurator, initializersExecutor, postJobsExecutor,
- sensorsExecutor, persistenceManager, sensorContext, index, eventBus, null, pi, graphStorage);
+ sensorsExecutor, persistenceManager, sensorContext, index, eventBus, null, pi, graphStorage, fsLogger);
}
/**
mavenPluginsConfigurator.execute(project);
mavenPhaseExecutor.execute(project);
initializersExecutor.execute();
+ fsLogger.log();
persistenceManager.setDelayedMode(true);
sensorsExecutor.execute(sensorContext);
import org.sonar.batch.phases.PhasesTimeProfiler;
import org.sonar.batch.scan.filesystem.DeprecatedFileSystemAdapter;
import org.sonar.batch.scan.filesystem.ExclusionFilters;
+import org.sonar.batch.scan.filesystem.FileSystemLogger;
import org.sonar.batch.scan.filesystem.LanguageFilters;
import org.sonar.batch.scan.filesystem.ModuleFileSystemProvider;
import org.sonar.core.qualitymodel.DefaultModelFinder;
container.addSingleton(DefaultProjectClasspath.class);
container.addPicoAdapter(new ModuleFileSystemProvider());
container.addSingleton(DeprecatedFileSystemAdapter.class);
+ container.addSingleton(FileSystemLogger.class);
// the Snapshot component will be removed when asynchronous measures are improved (required for AsynchronousMeasureSensor)
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.HiddenFileFilter;
import org.apache.commons.io.filefilter.IOFileFilter;
+import org.apache.commons.lang.StringUtils;
+import org.sonar.api.CoreProperties;
+import org.sonar.api.config.Settings;
import org.sonar.api.scan.filesystem.FileQuery;
import org.sonar.api.scan.filesystem.FileSystemFilter;
import org.sonar.api.scan.filesystem.FileType;
private static final IOFileFilter DIR_FILTER = FileFilterUtils.and(HiddenFileFilter.VISIBLE, FileFilterUtils.notFileFilter(FileFilterUtils.prefixFileFilter(".")));
- private final Charset sourceCharset;
+ private Settings settings;
private File baseDir, workingDir, buildDir;
- private List<File> sourceDirs, testDirs, binaryDirs;
- private final PathResolver pathResolver = new PathResolver();
- private final List<FileSystemFilter> fsFilters;
- private final LanguageFilters languageFilters;
-
- private DefaultModuleFileSystem(Builder builder) {
- sourceCharset = builder.sourceCharset;
- baseDir = builder.baseDir;
- buildDir = builder.buildDir;
- workingDir = builder.workingDir;
- sourceDirs = ImmutableList.copyOf(builder.sourceDirs);
- testDirs = ImmutableList.copyOf(builder.testDirs);
- binaryDirs = ImmutableList.copyOf(builder.binaryDirs);
- fsFilters = ImmutableList.copyOf(builder.fsFilters);
- languageFilters = builder.languageFilters;
+ private List<File> sourceDirs = Lists.newArrayList();
+ private List<File> testDirs = Lists.newArrayList();
+ private List<File> binaryDirs = Lists.newArrayList();
+ private PathResolver pathResolver = new PathResolver();
+ private List<FileSystemFilter> fsFilters = Lists.newArrayList();
+ private LanguageFilters languageFilters;
+
+ DefaultModuleFileSystem() {
}
public File baseDir() {
}
public Charset sourceCharset() {
- return sourceCharset;
+ final Charset charset;
+ String encoding = settings.getString(CoreProperties.ENCODING_PROPERTY);
+ if (StringUtils.isNotEmpty(encoding)) {
+ charset = Charset.forName(StringUtils.trim(encoding));
+ } else {
+ charset = Charset.defaultCharset();
+ }
+ return charset;
+ }
+
+ boolean isDefaultSourceCharset() {
+ return settings.hasKey(CoreProperties.ENCODING_PROPERTY);
}
public File workingDir() {
return workingDir;
}
- List<FileSystemFilter> fsFilters() {
+ List<FileSystemFilter> filters() {
return fsFilters;
}
return true;
}
- /**
- * Breaks immutability but it's required to allow Maven Plugins to be executed and to change project structure.
- */
public void resetDirs(File basedir, File buildDir, List<File> sourceDirs, List<File> testDirs, List<File> binaryDirs) {
Preconditions.checkNotNull(basedir, "Basedir can't be null");
this.baseDir = basedir;
return builder.build();
}
- static final class Builder {
- private Charset sourceCharset;
- private File baseDir, workingDir, buildDir;
- private List<File> sourceDirs = Lists.newArrayList(), testDirs = Lists.newArrayList(), binaryDirs = Lists.newArrayList();
- private List<FileSystemFilter> fsFilters = Lists.newArrayList();
- private LanguageFilters languageFilters;
-
- Builder sourceCharset(Charset c) {
- this.sourceCharset = c;
- return this;
- }
-
- Builder baseDir(File d) {
- this.baseDir = d;
- return this;
- }
+ DefaultModuleFileSystem setSettings(Settings settings) {
+ this.settings = settings;
+ return this;
+ }
- Builder buildDir(File d) {
- this.buildDir = d;
- return this;
- }
+ DefaultModuleFileSystem setBaseDir(File baseDir) {
+ this.baseDir = baseDir;
+ return this;
+ }
- Builder workingDir(File d) {
- this.workingDir = d;
- return this;
- }
+ DefaultModuleFileSystem setWorkingDir(File workingDir) {
+ this.workingDir = workingDir;
+ return this;
+ }
- Builder addSourceDir(File d) {
- sourceDirs.add(d);
- return this;
- }
+ DefaultModuleFileSystem setBuildDir(File buildDir) {
+ this.buildDir = buildDir;
+ return this;
+ }
- Builder addTestDir(File d) {
- testDirs.add(d);
- return this;
+ DefaultModuleFileSystem addFilters(FileSystemFilter... f) {
+ for (FileSystemFilter filter : f) {
+ this.fsFilters.add(filter);
}
+ return this;
+ }
- Builder addBinaryDir(File d) {
- binaryDirs.add(d);
- return this;
- }
+ DefaultModuleFileSystem setLanguageFilters(LanguageFilters languageFilters) {
+ this.languageFilters = languageFilters;
+ return this;
+ }
- Builder addFsFilter(FileSystemFilter f) {
- fsFilters.add(f);
- return this;
- }
+ DefaultModuleFileSystem addSourceDir(File d) {
+ this.sourceDirs.add(d);
+ return this;
+ }
- Builder languageFilters(LanguageFilters l) {
- languageFilters = l;
- return this;
- }
+ DefaultModuleFileSystem addTestDir(File d) {
+ this.testDirs.add(d);
+ return this;
+ }
- DefaultModuleFileSystem build() {
- Preconditions.checkNotNull(baseDir, "Module base directory is not set");
- Preconditions.checkNotNull(workingDir, "Module working directory is not set");
- Preconditions.checkNotNull(sourceCharset, "Module source charset is not set");
- return new DefaultModuleFileSystem(this);
- }
+ DefaultModuleFileSystem addBinaryDir(File d) {
+ this.binaryDirs.add(d);
+ return this;
}
}
}
public ProjectFileSystem addSourceDir(File dir) {
- throw new UnsupportedOperationException("File system is immutable");
+ target.addSourceDir(dir);
+ return this;
}
public List<File> getTestDirs() {
}
public ProjectFileSystem addTestDir(File dir) {
- throw new UnsupportedOperationException("File system is immutable");
+ target.addTestDir(dir);
+ return this;
}
public File getReportOutputDir() {
public boolean accept(File file, FileSystemFilter.Context context) {
return !pattern.match(context);
}
+
+ @Override
+ public String toString() {
+ return "Excludes: " + pattern;
+ }
}
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * Sonar is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+package org.sonar.batch.scan.filesystem;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Joiner;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sonar.api.scan.filesystem.FileSystemFilter;
+
+import java.io.File;
+import java.nio.charset.Charset;
+import java.util.List;
+import java.util.Locale;
+
+public class FileSystemLogger {
+
+ private final DefaultModuleFileSystem fs;
+
+ public FileSystemLogger(DefaultModuleFileSystem fs) {
+ this.fs = fs;
+ }
+
+ public void log() {
+ doLog(LoggerFactory.getLogger(getClass()));
+ }
+
+ @VisibleForTesting
+ void doLog(Logger logger) {
+ logDir(logger, "Base dir: ", fs.baseDir());
+ logDir(logger, "Working dir: ", fs.workingDir());
+ logDirs(logger, "Source dirs: ", fs.sourceDirs());
+ logDirs(logger, "Test dirs: ", fs.testDirs());
+ logDirs(logger, "Binary dirs: ", fs.binaryDirs());
+ logFilters(logger, fs.filters());
+ logEncoding(logger, fs.sourceCharset());
+ }
+
+ private void logEncoding(Logger logger, Charset charset) {
+ if (!fs.isDefaultSourceCharset()) {
+ logger.info("Source encoding: " + charset.displayName() + ", default locale: " + Locale.getDefault());
+ } else {
+ logger.warn("Source encoding is platform dependent (" + charset.displayName() + "), default locale: " + Locale.getDefault());
+ }
+ }
+
+ private void logFilters(Logger logger, List<FileSystemFilter> filters) {
+ for (FileSystemFilter filter : filters) {
+ logger.info(filter.toString());
+ }
+ }
+
+ private void logDirs(Logger logger, String label, List<File> dirs) {
+ if (!dirs.isEmpty()) {
+ logger.info(label + Joiner.on(", ").join(dirs));
+ }
+ }
+
+ private void logDir(Logger logger, String label, File dir) {
+ if (dir != null) {
+ logger.info(label + dir.getAbsolutePath());
+ }
+ }
+}
public boolean accept(File file, FileSystemFilter.Context context) {
return pattern.match(context);
}
+
+ @Override
+ public String toString() {
+ return "Includes: " + pattern;
+ }
}
*/
package org.sonar.batch.scan.filesystem;
-import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
import org.apache.commons.io.FileUtils;
-import org.apache.commons.lang.StringUtils;
import org.picocontainer.injectors.ProviderAdapter;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.sonar.api.CoreProperties;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.config.Settings;
import org.sonar.api.scan.filesystem.FileSystemFilter;
import org.sonar.batch.bootstrap.TempDirectories;
import java.io.File;
-import java.nio.charset.Charset;
import java.util.List;
-import java.util.Locale;
/**
* @since 3.5
*/
public class ModuleFileSystemProvider extends ProviderAdapter {
- private static final Logger LOG = LoggerFactory.getLogger(ModuleFileSystemProvider.class);
private DefaultModuleFileSystem singleton;
public DefaultModuleFileSystem provide(ProjectDefinition module, PathResolver pathResolver, TempDirectories tempDirectories,
LanguageFilters languageFilters, Settings settings, FileSystemFilter[] pluginFileFilters) {
if (singleton == null) {
- DefaultModuleFileSystem.Builder builder = new DefaultModuleFileSystem.Builder();
-
- // dependencies
- builder.languageFilters(languageFilters);
-
- // files and directories
- // TODO should the basedir always exist ? If yes, then we check also check that it's a dir but not a file
- builder.baseDir(module.getBaseDir());
- builder.buildDir(module.getBuildDir());
- builder.sourceCharset(guessCharset(settings));
- builder.workingDir(guessWorkingDir(module, tempDirectories));
- initBinaryDirs(module, pathResolver, builder);
- initSources(module, pathResolver, builder);
- initTests(module, pathResolver, builder);
-
- // file filters
- initCustomFilters(builder, pluginFileFilters);
- singleton = builder.build();
+ DefaultModuleFileSystem fs = new DefaultModuleFileSystem();
+ fs.setLanguageFilters(languageFilters);
+ fs.setBaseDir(module.getBaseDir());
+ fs.setBuildDir(module.getBuildDir());
+ fs.setSettings(settings);
+ fs.setWorkingDir(guessWorkingDir(module, tempDirectories));
+ fs.addFilters(pluginFileFilters);
+ initBinaryDirs(module, pathResolver, fs);
+ initSources(module, pathResolver, fs);
+ initTests(module, pathResolver, fs);
+ singleton = fs;
}
return singleton;
}
File workDir = module.getWorkDir();
if (workDir == null) {
workDir = tempDirectories.getDir("work");
- LOG.warn("Working dir is not set. Using: " + workDir.getAbsolutePath());
} else {
- LOG.info("Working dir: " + workDir.getAbsolutePath());
try {
FileUtils.forceMkdir(workDir);
} catch (Exception e) {
return workDir;
}
- private Charset guessCharset(Settings settings) {
- final Charset charset;
- String encoding = settings.getString(CoreProperties.ENCODING_PROPERTY);
- if (StringUtils.isNotEmpty(encoding)) {
- charset = Charset.forName(StringUtils.trim(encoding));
- LOG.info("Source encoding: " + charset.displayName() + ", default locale: " + Locale.getDefault());
- } else {
- charset = Charset.defaultCharset();
- LOG.warn("Source encoding is platform dependent (" + charset.displayName() + "), default locale: " + Locale.getDefault());
- }
- return charset;
- }
-
- private void initSources(ProjectDefinition module, PathResolver pathResolver, DefaultModuleFileSystem.Builder builder) {
- List<String> paths = Lists.newArrayList();
+ private void initSources(ProjectDefinition module, PathResolver pathResolver, DefaultModuleFileSystem fs) {
for (String sourcePath : module.getSourceDirs()) {
File dir = pathResolver.relativeFile(module.getBaseDir(), sourcePath);
if (dir.isDirectory() && dir.exists()) {
- paths.add(dir.getAbsolutePath());
- builder.addSourceDir(dir);
+ fs.addSourceDir(dir);
}
}
- if (!paths.isEmpty()) {
- LOG.info("Source dirs: " + Joiner.on(", ").join(paths));
- }
List<File> sourceFiles = pathResolver.relativeFiles(module.getBaseDir(), module.getSourceFiles());
if (!sourceFiles.isEmpty()) {
- LOG.info("Source files: ");
- for (File sourceFile : sourceFiles) {
- LOG.info(" " + sourceFile.getAbsolutePath());
- }
- builder.addFsFilter(new WhiteListFileFilter(FileType.SOURCE, ImmutableSet.copyOf(sourceFiles)));
+ fs.addFilters(new WhiteListFileFilter(FileType.SOURCE, ImmutableSet.copyOf(sourceFiles)));
}
}
- private void initTests(ProjectDefinition module, PathResolver pathResolver, DefaultModuleFileSystem.Builder builder) {
- List<String> paths = Lists.newArrayList();
+ private void initTests(ProjectDefinition module, PathResolver pathResolver, DefaultModuleFileSystem fs) {
for (String testPath : module.getTestDirs()) {
File dir = pathResolver.relativeFile(module.getBaseDir(), testPath);
if (dir.exists() && dir.isDirectory()) {
- paths.add(dir.getAbsolutePath());
- builder.addTestDir(dir);
+ fs.addTestDir(dir);
}
}
- if (!paths.isEmpty()) {
- LOG.info("Test dirs: " + Joiner.on(", ").join(paths));
- }
-
List<File> testFiles = pathResolver.relativeFiles(module.getBaseDir(), module.getTestFiles());
if (!testFiles.isEmpty()) {
- LOG.info("Test files:");
- for (File testFile : testFiles) {
- LOG.info(" " + testFile.getAbsolutePath());
- }
- builder.addFsFilter(new WhiteListFileFilter(FileType.TEST, ImmutableSet.copyOf(testFiles)));
+ fs.addFilters(new WhiteListFileFilter(FileType.TEST, ImmutableSet.copyOf(testFiles)));
}
}
- private void initCustomFilters(DefaultModuleFileSystem.Builder builder, FileSystemFilter[] pluginFileFilters) {
- for (FileSystemFilter pluginFileFilter : pluginFileFilters) {
- builder.addFsFilter(pluginFileFilter);
- }
- }
- private void initBinaryDirs(ProjectDefinition module, PathResolver pathResolver, DefaultModuleFileSystem.Builder builder) {
+ private void initBinaryDirs(ProjectDefinition module, PathResolver pathResolver, DefaultModuleFileSystem fs) {
for (String path : module.getBinaries()) {
File dir = pathResolver.relativeFile(module.getBaseDir(), path);
- LOG.info("Binary dir: " + dir.getAbsolutePath());
- builder.addBinaryDir(dir);
+ fs.addBinaryDir(dir);
}
}
}
*/
package org.sonar.batch.scan.filesystem;
+import com.google.common.base.Joiner;
+import com.google.common.base.Preconditions;
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.SystemUtils;
import org.sonar.api.scan.filesystem.FileSystemFilter;
import org.sonar.api.scan.filesystem.FileType;
private final Set<File> files;
WhiteListFileFilter(FileType fileType, Set<File> files) {
+ Preconditions.checkNotNull(fileType);
+ Preconditions.checkNotNull(files);
this.fileType = fileType;
this.files = files;
}
public boolean accept(File file, Context context) {
return !context.type().equals(fileType) || files.contains(file);
}
+
+ @Override
+ public String toString() {
+ return StringUtils.capitalize(fileType.name().toLowerCase()) + " files: " + SystemUtils.LINE_SEPARATOR +
+ Joiner.on(SystemUtils.LINE_SEPARATOR).join(files);
+ }
}
*/
package org.sonar.batch.scan.filesystem;
-import com.google.common.base.Charsets;
import org.apache.commons.io.filefilter.FileFilterUtils;
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.AbstractLanguage;
import org.sonar.api.resources.Languages;
import org.sonar.api.scan.filesystem.FileQuery;
import org.sonar.api.scan.filesystem.FileSystemFilter;
-import org.sonar.api.scan.filesystem.PathResolver;
import java.io.File;
import java.io.IOException;
+import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.List;
public TemporaryFolder temp = new TemporaryFolder();
@Test
- public void test_builder() throws IOException {
+ public void test_new_file_system() throws IOException {
File basedir = temp.newFolder("base");
File workingDir = temp.newFolder("work");
- PathResolver pathResolver = mock(PathResolver.class);
LanguageFilters languageFilters = mock(LanguageFilters.class);
FileSystemFilter fileFilter = mock(FileSystemFilter.class);
- DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem.Builder()
- .baseDir(basedir)
- .workingDir(workingDir)
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setWorkingDir(workingDir)
.addBinaryDir(new File(basedir, "target/classes"))
.addSourceDir(new File(basedir, "src/main/java"))
.addSourceDir(new File(basedir, "src/main/groovy"))
.addTestDir(new File(basedir, "src/test/java"))
- .addFsFilter(fileFilter)
- .sourceCharset(Charsets.UTF_8)
- .languageFilters(languageFilters)
- .build();
+ .addFilters(fileFilter)
+ .setLanguageFilters(languageFilters);
assertThat(fileSystem).isNotNull();
assertThat(fileSystem.baseDir().getCanonicalPath()).isEqualTo(basedir.getCanonicalPath());
assertThat(fileSystem.sourceDirs()).hasSize(2);
assertThat(fileSystem.testDirs()).hasSize(1);
assertThat(fileSystem.binaryDirs()).hasSize(1);
- assertThat(fileSystem.sourceCharset().name()).isEqualTo("UTF-8");
- assertThat(fileSystem.fsFilters()).containsOnly(fileFilter);
+ assertThat(fileSystem.filters()).containsOnly(fileFilter);
assertThat(fileSystem.languageFilters()).isSameAs(languageFilters);
}
+ @Test
+ public void default_source_encoding() {
+ File basedir = temp.newFolder("base");
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setSettings(new Settings());
+
+ assertThat(fileSystem.sourceCharset()).isEqualTo(Charset.defaultCharset());
+ }
+
+ @Test
+ public void source_encoding_is_set() {
+ File basedir = temp.newFolder("base");
+ Settings settings = new Settings();
+ settings.setProperty(CoreProperties.ENCODING_PROPERTY, "UTF-8");
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setSettings(settings);
+
+ assertThat(fileSystem.sourceCharset()).isEqualTo(Charset.forName("UTF-8"));
+ }
+
@Test
public void should_exclude_dirs_starting_with_dot() throws IOException {
File basedir = new File(resourcesDir(), "exclude_dir_starting_with_dot");
- DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem.Builder()
- .baseDir(basedir)
- .sourceCharset(Charsets.UTF_8)
- .workingDir(temp.newFolder())
- .addSourceDir(new File(basedir, "src"))
- .build();
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setWorkingDir(temp.newFolder())
+ .addSourceDir(new File(basedir, "src"));
List<File> files = fileSystem.files(FileQuery.onSource());
assertThat(files).hasSize(1);
@Test
public void should_load_source_files_by_language() throws IOException {
File basedir = new File(resourcesDir(), "main_and_test_files");
- DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem.Builder()
- .baseDir(basedir)
- .sourceCharset(Charsets.UTF_8)
- .workingDir(temp.newFolder())
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setWorkingDir(temp.newFolder())
.addSourceDir(new File(basedir, "src/main/java"))
.addTestDir(new File(basedir, "src/test/java"))
- .languageFilters(new LanguageFilters(new Languages(new Java(), new Php())))
- .build();
+ .setLanguageFilters(new LanguageFilters(new Languages(new Java(), new Php())));
List<File> files = fileSystem.files(FileQuery.onSource().onLanguage("java"));
assertThat(files).hasSize(2);
@Test
public void should_load_test_files() throws IOException {
File basedir = new File(resourcesDir(), "main_and_test_files");
- DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem.Builder()
- .baseDir(basedir)
- .sourceCharset(Charsets.UTF_8)
- .workingDir(temp.newFolder())
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setWorkingDir(temp.newFolder())
.addSourceDir(new File(basedir, "src/main/java"))
- .addTestDir(new File(basedir, "src/test/java"))
- .build();
+ .addTestDir(new File(basedir, "src/test/java"));
assertThat(fileSystem.testDirs()).hasSize(1);
List<File> testFiles = fileSystem.files(FileQuery.onTest());
@Test
public void should_load_test_files_by_language() throws IOException {
File basedir = new File(resourcesDir(), "main_and_test_files");
- DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem.Builder()
- .baseDir(basedir)
- .sourceCharset(Charsets.UTF_8)
- .workingDir(temp.newFolder())
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setWorkingDir(temp.newFolder())
.addSourceDir(new File(basedir, "src/main/java"))
.addTestDir(new File(basedir, "src/test/java"))
- .languageFilters(new LanguageFilters(new Languages(new Java(), new Php())))
- .build();
+ .setLanguageFilters(new LanguageFilters(new Languages(new Java(), new Php())));
List<File> testFiles = fileSystem.files(FileQuery.onTest().onLanguage("java"));
assertThat(testFiles).hasSize(2);
@Test
public void should_apply_file_filters() throws IOException {
File basedir = new File(resourcesDir(), "main_and_test_files");
- DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem.Builder()
- .baseDir(basedir)
- .sourceCharset(Charsets.UTF_8)
- .workingDir(temp.newFolder())
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setWorkingDir(temp.newFolder())
.addSourceDir(new File(basedir, "src/main/java"))
- .addFsFilter(new FileFilterWrapper(FileFilterUtils.nameFileFilter("Foo.java")))
- .build();
+ .addFilters(new FileFilterWrapper(FileFilterUtils.nameFileFilter("Foo.java")));
List<File> files = fileSystem.files(FileQuery.onSource());
assertThat(files).hasSize(1);
@Test
public void test_reset_dirs() throws IOException {
File basedir = temp.newFolder();
- DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem.Builder()
- .baseDir(basedir)
- .sourceCharset(Charsets.UTF_8)
- .workingDir(basedir)
+ DefaultModuleFileSystem fileSystem = new DefaultModuleFileSystem()
+ .setBaseDir(basedir)
+ .setWorkingDir(basedir)
.addSourceDir(new File(basedir, "src/main/java"))
- .addFsFilter(new FileFilterWrapper(FileFilterUtils.nameFileFilter("Foo.java")))
- .build();
+ .addFilters(new FileFilterWrapper(FileFilterUtils.nameFileFilter("Foo.java")));
File existingDir = temp.newFolder("new_folder");
File notExistingDir = new File(existingDir, "not_exist");
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * Sonar is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+package org.sonar.batch.scan.filesystem;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.slf4j.Logger;
+import org.sonar.api.config.Settings;
+
+import java.io.File;
+
+import static org.mockito.AdditionalMatchers.and;
+import static org.mockito.Matchers.contains;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class FileSystemLoggerTest {
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
+ @Test
+ public void log() {
+ DefaultModuleFileSystem fs = new DefaultModuleFileSystem();
+ File src = temp.newFolder("src");
+ File test = temp.newFolder("test");
+ File base = temp.newFolder("base");
+ fs.setSettings(new Settings());
+ fs.setBaseDir(base);
+ fs.addSourceDir(src);
+ fs.addTestDir(test);
+
+ Logger slf4j = mock(Logger.class);
+ new FileSystemLogger(fs).doLog(slf4j);
+
+ verify(slf4j).info(and(contains("Base dir:"), contains(base.getAbsolutePath())));
+ verify(slf4j).info(and(contains("Source dirs:"), contains(src.getAbsolutePath())));
+ verify(slf4j).info(and(contains("Test dirs:"), contains(test.getAbsolutePath())));
+ }
+}
assertThat(filter.accept(new File("Foo.java"), context)).isTrue();
assertThat(filter.accept(new File("Other.java"), context)).isTrue();
}
+
+ @Test
+ public void test_toString() throws IOException {
+ WhiteListFileFilter filter = new WhiteListFileFilter(FileType.SOURCE, Sets.newHashSet(
+ new File("Foo.java"),
+ new File("Bar.java")
+ ));
+
+ assertThat(filter.toString())
+ .contains("Source files:")
+ .contains("Foo.java")
+ .contains("Bar.java");
+ }
}
projects / sonarqube.git / commitdiff