import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.regex.Pattern;
-import javax.annotation.Nullable;
import org.sonar.api.batch.fs.internal.AbstractProjectOrModule;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.scm.ScmProvider;
import org.sonar.scanner.rule.QualityProfiles;
import org.sonar.scanner.scan.ScanProperties;
import org.sonar.scanner.scan.branch.BranchConfiguration;
+import org.sonar.scanner.scan.filesystem.InputComponentStore;
import org.sonar.scanner.scm.ScmConfiguration;
import org.sonar.scanner.scm.ScmRevision;
private final BranchConfiguration branchConfiguration;
private final ScmRevision scmRevision;
private final ForkDateSupplier forkDateSupplier;
- @Nullable
+ private final InputComponentStore componentStore;
private final ScmConfiguration scmConfiguration;
public MetadataPublisher(ProjectInfo projectInfo, InputModuleHierarchy moduleHierarchy, ScanProperties properties,
QualityProfiles qProfiles, CpdSettings cpdSettings, ScannerPluginRepository pluginRepository, BranchConfiguration branchConfiguration,
- ScmRevision scmRevision, ForkDateSupplier forkDateSupplier, @Nullable ScmConfiguration scmConfiguration) {
+ ScmRevision scmRevision, ForkDateSupplier forkDateSupplier, InputComponentStore componentStore, ScmConfiguration scmConfiguration) {
this.projectInfo = projectInfo;
this.moduleHierarchy = moduleHierarchy;
this.properties = properties;
this.branchConfiguration = branchConfiguration;
this.scmRevision = scmRevision;
this.forkDateSupplier = forkDateSupplier;
+ this.componentStore = componentStore;
this.scmConfiguration = scmConfiguration;
}
- public MetadataPublisher(ProjectInfo projectInfo, InputModuleHierarchy moduleHierarchy, ScanProperties properties, QualityProfiles qProfiles,
- CpdSettings cpdSettings, ScannerPluginRepository pluginRepository, BranchConfiguration branchConfiguration, ScmRevision scmRevision, ForkDateSupplier forkDateSupplier) {
- this(projectInfo, moduleHierarchy, properties, qProfiles, cpdSettings, pluginRepository, branchConfiguration, scmRevision, forkDateSupplier, null);
- }
-
@Override
public void publish(ScannerReportWriter writer) {
AbstractProjectOrModule rootProject = moduleHierarchy.root();
addScmInformation(builder);
addForkPoint(builder);
+ addNotAnalyzedFileCountsByLanguage(builder);
for (QProfile qp : qProfiles.findAll()) {
builder.putQprofilesPerLanguage(qp.getLanguage(), ScannerReport.Metadata.QProfile.newBuilder()
}
}
- if (scmConfiguration != null) {
- ScmProvider scmProvider = scmConfiguration.provider();
- if (scmProvider != null) {
- Path projectBasedir = moduleHierarchy.root().getBaseDir();
- try {
- builder.setRelativePathFromScmRoot(toSonarQubePath(scmProvider.relativePathFromScmRoot(projectBasedir)));
- } catch (UnsupportedOperationException e) {
- LOG.debug(e.getMessage());
- }
- }
+ ScmProvider scmProvider = scmConfiguration.provider();
+ if (scmProvider == null) {
+ return;
+ }
+
+ Path projectBasedir = moduleHierarchy.root().getBaseDir();
+ try {
+ builder.setRelativePathFromScmRoot(toSonarQubePath(scmProvider.relativePathFromScmRoot(projectBasedir)));
+ } catch (UnsupportedOperationException e) {
+ LOG.debug(e.getMessage());
}
}
}
}
+ private void addNotAnalyzedFileCountsByLanguage(ScannerReport.Metadata.Builder builder) {
+ builder.putAllNotAnalyzedFilesByLanguage(componentStore.getNotAnalysedFilesByLanguage());
+ }
+
private void addBranchInformation(ScannerReport.Metadata.Builder builder) {
builder.setBranchName(branchConfiguration.branchName());
BranchType branchType = toProtobufBranchType(branchConfiguration.branchType());
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.InputFile.Type;
import org.sonar.api.batch.fs.InputFileFilter;
+import org.sonar.api.batch.fs.internal.DefaultIndexedFile;
+import org.sonar.api.batch.fs.internal.DefaultInputFile;
+import org.sonar.api.batch.fs.internal.DefaultInputModule;
+import org.sonar.api.batch.fs.internal.DefaultInputProject;
import org.sonar.api.batch.fs.internal.SensorStrategy;
import org.sonar.api.batch.scm.IgnoreCommand;
import org.sonar.api.notifications.AnalysisWarnings;
import org.sonar.api.utils.MessageException;
import org.sonar.api.utils.log.Logger;
import org.sonar.api.utils.log.Loggers;
-import org.sonar.api.batch.fs.internal.DefaultIndexedFile;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.DefaultInputModule;
-import org.sonar.api.batch.fs.internal.DefaultInputProject;
import org.sonar.scanner.issue.ignore.scanner.IssueExclusionsLoader;
import org.sonar.scanner.scan.ScanProperties;
import org.sonar.scanner.util.ProgressReport;
public class FileIndexer {
private static final Logger LOG = Loggers.get(FileIndexer.class);
+
private final AnalysisWarnings analysisWarnings;
private final ScanProperties properties;
private final InputFileFilter[] filters;
}
public FileIndexer(DefaultInputProject project, ScannerComponentIdGenerator scannerComponentIdGenerator, InputComponentStore componentStore,
- ProjectExclusionFilters projectExclusionFilters, ProjectCoverageAndDuplicationExclusions projectCoverageAndDuplicationExclusions, IssueExclusionsLoader issueExclusionsLoader,
- MetadataGenerator metadataGenerator, SensorStrategy sensorStrategy, LanguageDetection languageDetection, AnalysisWarnings analysisWarnings, ScanProperties properties) {
- this(project, scannerComponentIdGenerator, componentStore, projectExclusionFilters, projectCoverageAndDuplicationExclusions, issueExclusionsLoader, metadataGenerator,
- sensorStrategy, languageDetection, analysisWarnings, properties, new InputFileFilter[0]);
+ ProjectExclusionFilters projectExclusionFilters, ProjectCoverageAndDuplicationExclusions projectCoverageAndDuplicationExclusions,
+ IssueExclusionsLoader issueExclusionsLoader, MetadataGenerator metadataGenerator, SensorStrategy sensorStrategy,
+ LanguageDetection languageDetection, AnalysisWarnings analysisWarnings, ScanProperties properties) {
+ this(project, scannerComponentIdGenerator, componentStore, projectExclusionFilters, projectCoverageAndDuplicationExclusions, issueExclusionsLoader,
+ metadataGenerator, sensorStrategy, languageDetection, analysisWarnings, properties, new InputFileFilter[0]);
}
void indexFile(DefaultInputModule module, ModuleExclusionFilters moduleExclusionFilters, ModuleCoverageAndDuplicationExclusions moduleCoverageAndDuplicationExclusions,
private static String pluralizeFiles(int count) {
return count == 1 ? "file" : "files";
}
-
}
*/
package org.sonar.scanner.scan.filesystem;
+import com.google.common.collect.ImmutableMap;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
+import java.util.regex.Pattern;
import java.util.stream.Stream;
import javax.annotation.CheckForNull;
+import org.sonar.api.SonarEdition;
+import org.sonar.api.SonarRuntime;
import org.sonar.api.batch.fs.InputComponent;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.internal.DefaultFileSystem;
* exclusion patterns are already applied.
*/
public class InputComponentStore extends DefaultFileSystem.Cache {
+ private static final Map<String, Pattern> FILE_PATTERN_BY_LANGUAGE = ImmutableMap.of(
+ "C", Pattern.compile(".*\\.c", Pattern.CASE_INSENSITIVE),
+ "C++", Pattern.compile(".*\\.cpp|.*\\.cc|.*\\.cxx|.*\\.c\\+\\+", Pattern.CASE_INSENSITIVE));
private final SortedSet<String> globalLanguagesCache = new TreeSet<>();
private final Map<String, SortedSet<String>> languagesCache = new HashMap<>();
private final Map<String, Set<InputFile>> filesByNameCache = new HashMap<>();
private final Map<String, Set<InputFile>> filesByExtensionCache = new HashMap<>();
private final BranchConfiguration branchConfiguration;
+ private final SonarRuntime sonarRuntime;
+ private final Map<String, Integer> notAnalysedFilesByLanguage = new HashMap<>();
- public InputComponentStore(BranchConfiguration branchConfiguration) {
+ public InputComponentStore(BranchConfiguration branchConfiguration, SonarRuntime sonarRuntime) {
this.branchConfiguration = branchConfiguration;
+ this.sonarRuntime = sonarRuntime;
}
public Collection<InputComponent> all() {
public InputComponentStore put(String moduleKey, InputFile inputFile) {
DefaultInputFile file = (DefaultInputFile) inputFile;
+ updateNotAnalysedCAndCppFileCount(file);
+
addToLanguageCache(moduleKey, file);
inputFileByModuleCache.computeIfAbsent(moduleKey, x -> new HashMap<>()).put(file.getModuleRelativePath(), inputFile);
inputModuleKeyByFileCache.put(inputFile, moduleKey);
throw new UnsupportedOperationException();
}
+ private void updateNotAnalysedCAndCppFileCount(DefaultInputFile inputFile) {
+ if (!SonarEdition.COMMUNITY.equals(sonarRuntime.getEdition())) {
+ return;
+ }
+
+ FILE_PATTERN_BY_LANGUAGE.forEach((language, filePattern) -> {
+ if (filePattern.matcher(inputFile.filename()).matches()) {
+ notAnalysedFilesByLanguage.put(language, notAnalysedFilesByLanguage.getOrDefault(language, 0) + 1);
+ }
+ });
+ }
+
+ public Map<String, Integer> getNotAnalysedFilesByLanguage() {
+ return ImmutableMap.copyOf(notAnalysedFilesByLanguage);
+ }
}
private static final Logger LOG = Loggers.get(ProjectFileIndexer.class);
private final ProjectExclusionFilters projectExclusionFilters;
private final ProjectCoverageAndDuplicationExclusions projectCoverageAndDuplicationExclusions;
- private ScmConfiguration scmConfiguration;
+ private final ScmConfiguration scmConfiguration;
private final InputComponentStore componentStore;
private final InputModuleHierarchy inputModuleHierarchy;
private final GlobalConfiguration globalConfig;
return count == 1 ? "file" : "files";
}
- private void indexFiles(DefaultInputModule module, ModuleExclusionFilters moduleExclusionFilters, ModuleCoverageAndDuplicationExclusions moduleCoverageAndDuplicationExclusions,
- List<Path> sources, Type type, ExclusionCounter exclusionCounter) {
+ private void indexFiles(DefaultInputModule module, ModuleExclusionFilters moduleExclusionFilters,
+ ModuleCoverageAndDuplicationExclusions moduleCoverageAndDuplicationExclusions, List<Path> sources, Type type, ExclusionCounter exclusionCounter) {
try {
for (Path dirOrFile : sources) {
if (dirOrFile.toFile().isDirectory()) {
indexDirectory(module, moduleExclusionFilters, moduleCoverageAndDuplicationExclusions, dirOrFile, type, exclusionCounter);
} else {
- fileIndexer.indexFile(module, moduleExclusionFilters, moduleCoverageAndDuplicationExclusions, dirOrFile, type, progressReport, exclusionCounter, ignoreCommand);
+ fileIndexer.indexFile(module, moduleExclusionFilters, moduleCoverageAndDuplicationExclusions, dirOrFile, type, progressReport, exclusionCounter,
+ ignoreCommand);
}
}
} catch (IOException e) {
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
import org.mockito.ArgumentMatchers;
+import org.sonar.api.SonarRuntime;
import org.sonar.api.utils.log.LogTester;
import org.sonar.api.utils.log.LoggerLevel;
import org.sonar.core.util.CloseableIterator;
public ExpectedException thrown = ExpectedException.none();
private CpdExecutor executor;
- private ExecutorService executorService = mock(ExecutorService.class);
- private CpdSettings settings = mock(CpdSettings.class);
- private ReportPublisher publisher = mock(ReportPublisher.class);
- private SonarCpdBlockIndex index = new SonarCpdBlockIndex(publisher, settings);
+ private final ExecutorService executorService = mock(ExecutorService.class);
+ private final CpdSettings settings = mock(CpdSettings.class);
+ private final ReportPublisher publisher = mock(ReportPublisher.class);
+ private final SonarRuntime sonarRuntime = mock(SonarRuntime.class);
+ private final SonarCpdBlockIndex index = new SonarCpdBlockIndex(publisher, settings);
private ScannerReportReader reader;
private DefaultInputFile batchComponent1;
private DefaultInputFile batchComponent2;
when(publisher.getWriter()).thenReturn(new ScannerReportWriter(outputDir));
DefaultInputProject project = TestInputFileBuilder.newDefaultInputProject("foo", baseDir);
- componentStore = new InputComponentStore(mock(BranchConfiguration.class));
+ componentStore = new InputComponentStore(mock(BranchConfiguration.class), sonarRuntime);
executor = new CpdExecutor(settings, index, publisher, componentStore, executorService);
reader = new ScannerReportReader(outputDir);
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.sonar.api.CoreProperties;
+import org.sonar.api.SonarRuntime;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.InputFile.Type;
import static org.mockito.Mockito.when;
public class ComponentsPublisherTest {
+
+ private final SonarRuntime sonarRuntime = mock(SonarRuntime.class);
+
@Rule
public TemporaryFolder temp = new TemporaryFolder();
.setWorkDir(temp.newFolder());
DefaultInputProject project = new DefaultInputProject(rootDef, 1);
- InputComponentStore store = new InputComponentStore(branchConfiguration);
+ InputComponentStore store = new InputComponentStore(branchConfiguration, sonarRuntime);
Path moduleBaseDir = temp.newFolder().toPath();
ProjectDefinition module1Def = ProjectDefinition.create()
.setWorkDir(temp.newFolder());
DefaultInputProject project = new DefaultInputProject(rootDef, 1);
- InputComponentStore store = new InputComponentStore(branchConfiguration);
+ InputComponentStore store = new InputComponentStore(branchConfiguration, sonarRuntime);
DefaultInputFile file = new TestInputFileBuilder("foo", "src/Foo.java", 5)
.setLines(2)
.setWorkDir(temp.newFolder());
DefaultInputProject project = new DefaultInputProject(rootDef, 1);
- InputComponentStore store = new InputComponentStore(branchConfiguration);
+ InputComponentStore store = new InputComponentStore(branchConfiguration, sonarRuntime);
ComponentsPublisher publisher = new ComponentsPublisher(project, store);
publisher.publish(writer);
.setWorkDir(temp.newFolder());
DefaultInputProject project = new DefaultInputProject(rootDef, 1);
- InputComponentStore store = new InputComponentStore(branchConfiguration);
+ InputComponentStore store = new InputComponentStore(branchConfiguration, sonarRuntime);
ComponentsPublisher publisher = new ComponentsPublisher(project, store);
publisher.publish(writer);
import org.sonar.scanner.scan.ScanProperties;
import org.sonar.scanner.scan.branch.BranchConfiguration;
import org.sonar.scanner.scan.branch.BranchType;
+import org.sonar.scanner.scan.filesystem.InputComponentStore;
import org.sonar.scanner.scm.ScmConfiguration;
import org.sonar.scanner.scm.ScmRevision;
@Rule
public TemporaryFolder temp = new TemporaryFolder();
- private DefaultInputModule rootModule;
private MetadataPublisher underTest;
- private ScanProperties properties = mock(ScanProperties.class);
- private QualityProfiles qProfiles = mock(QualityProfiles.class);
- private ProjectInfo projectInfo = mock(ProjectInfo.class);
- private CpdSettings cpdSettings = mock(CpdSettings.class);
- private InputModuleHierarchy inputModuleHierarchy;
- private ForkDateSupplier forkDateSupplier = mock(ForkDateSupplier.class);
- private ScannerPluginRepository pluginRepository = mock(ScannerPluginRepository.class);
+ private final ScanProperties properties = mock(ScanProperties.class);
+ private final QualityProfiles qProfiles = mock(QualityProfiles.class);
+ private final ProjectInfo projectInfo = mock(ProjectInfo.class);
+ private final CpdSettings cpdSettings = mock(CpdSettings.class);
+ private final ForkDateSupplier forkDateSupplier = mock(ForkDateSupplier.class);
+ private final ScannerPluginRepository pluginRepository = mock(ScannerPluginRepository.class);
private BranchConfiguration branches;
private ScmConfiguration scmConfiguration;
- private ScmProvider scmProvider = mock(ScmProvider.class);
- private ScmRevision scmRevision = mock(ScmRevision.class);
+ private final ScmProvider scmProvider = mock(ScmProvider.class);
+ private final ScmRevision scmRevision = mock(ScmRevision.class);
+ private final InputComponentStore componentStore = mock(InputComponentStore.class);
@Before
public void prepare() throws IOException {
Path rootBaseDir = temp.newFolder().toPath();
Path moduleBaseDir = rootBaseDir.resolve("moduleDir");
Files.createDirectory(moduleBaseDir);
- rootModule = new DefaultInputModule(def
+ DefaultInputModule rootModule = new DefaultInputModule(def
.setBaseDir(rootBaseDir.toFile())
.setKey("root")
.setWorkDir(temp.newFolder()), TestInputFileBuilder.nextBatchId());
- inputModuleHierarchy = mock(InputModuleHierarchy.class);
+ InputModuleHierarchy inputModuleHierarchy = mock(InputModuleHierarchy.class);
when(inputModuleHierarchy.root()).thenReturn(rootModule);
DefaultInputModule child = new DefaultInputModule(ProjectDefinition.create()
.setKey("module")
scmConfiguration = mock(ScmConfiguration.class);
when(scmConfiguration.provider()).thenReturn(scmProvider);
underTest = new MetadataPublisher(projectInfo, inputModuleHierarchy, properties, qProfiles, cpdSettings,
- pluginRepository, branches, scmRevision, forkDateSupplier, scmConfiguration);
+ pluginRepository, branches, scmRevision, forkDateSupplier, componentStore, scmConfiguration);
}
@Test
assertThat(metadata.getProjectKey()).isEqualTo("root");
assertThat(metadata.getModulesProjectRelativePathByKeyMap()).containsOnly(entry("module", "modulePath"), entry("root", ""));
assertThat(metadata.getProjectVersion()).isEmpty();
+ assertThat(metadata.getNotAnalyzedFilesByLanguageCount()).isZero();
assertThat(metadata.getQprofilesPerLanguageMap()).containsOnly(entry("java", org.sonar.scanner.protocol.output.ScannerReport.Metadata.QProfile.newBuilder()
.setKey("q1")
.setName("Q1")
.setRulesUpdatedAt(date.getTime())
.build()));
assertThat(metadata.getPluginsByKey()).containsOnly(entry("java", org.sonar.scanner.protocol.output.ScannerReport.Metadata.Plugin.newBuilder()
- .setKey("java")
- .setUpdatedAt(12345)
- .build()),
+ .setKey("java")
+ .setUpdatedAt(12345)
+ .build()),
entry("php", org.sonar.scanner.protocol.output.ScannerReport.Metadata.Plugin.newBuilder()
.setKey("php")
.setUpdatedAt(45678)
.build()));
}
+ @Test
+ public void write_not_analysed_file_counts() throws Exception {
+ when(componentStore.getNotAnalysedFilesByLanguage()).thenReturn(ImmutableMap.of("c", 10, "cpp", 20));
+
+ File outputDir = temp.newFolder();
+ ScannerReportWriter writer = new ScannerReportWriter(outputDir);
+
+ underTest.publish(writer);
+
+ ScannerReportReader reader = new ScannerReportReader(outputDir);
+ ScannerReport.Metadata metadata = reader.readMetadata();
+ assertThat(metadata.getNotAnalyzedFilesByLanguageMap()).contains(entry("c", 10), entry("cpp", 20));
+ }
+
@Test
public void write_project_organization() throws Exception {
when(properties.organizationKey()).thenReturn(Optional.of("SonarSource"));
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
+import org.sonar.api.SonarRuntime;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputProject;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
.build();
DefaultInputProject rootProject = TestInputFileBuilder.newDefaultInputProject(moduleKey, baseDir);
- InputComponentStore componentStore = new InputComponentStore(mock(BranchConfiguration.class));
+ InputComponentStore componentStore = new InputComponentStore(mock(BranchConfiguration.class), mock(SonarRuntime.class));
componentStore.put(moduleKey, inputFile);
publisher = new SourcePublisher(componentStore);
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.slf4j.Logger;
+import org.sonar.api.SonarRuntime;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
import org.sonar.scanner.scan.branch.BranchConfiguration;
import org.sonar.scanner.scan.filesystem.InputComponentStore;
@Before
public void before() {
- store = new InputComponentStore(mock(BranchConfiguration.class));
+ store = new InputComponentStore(mock(BranchConfiguration.class), mock(SonarRuntime.class));
profiles = mock(QualityProfiles.class);
QProfile javaProfile = new QProfile("p1", "My Java profile", "java", null);
when(profiles.findByLanguage("java")).thenReturn(javaProfile);
import java.util.Arrays;
import org.junit.Test;
+import org.sonar.api.SonarRuntime;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.scanner.scan.branch.BranchConfiguration;
private DefaultInputModuleHierarchy moduleHierarchy;
public void createIndexer() {
- InputComponentStore componentStore = new InputComponentStore(mock(BranchConfiguration.class));
+ InputComponentStore componentStore = new InputComponentStore(mock(BranchConfiguration.class), mock(SonarRuntime.class));
moduleHierarchy = mock(DefaultInputModuleHierarchy.class);
indexer = new ModuleIndexer(componentStore, moduleHierarchy);
}
import java.nio.charset.StandardCharsets;
import java.util.LinkedList;
import java.util.List;
+import javax.annotation.Nullable;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
+import org.sonar.api.SonarEdition;
+import org.sonar.api.SonarRuntime;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.InputFile.Status;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
import org.sonar.scanner.scan.branch.BranchConfiguration;
+import static java.util.Optional.ofNullable;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
public class InputComponentStoreTest {
+
+ private final SonarRuntime sonarRuntime = mock(SonarRuntime.class);
+
@ClassRule
public static TemporaryFolder temp = new TemporaryFolder();
DefaultInputProject rootProject = TestInputFileBuilder.newDefaultInputProject(rootDef);
DefaultInputModule subModule = TestInputFileBuilder.newDefaultInputModule(moduleDef);
- InputComponentStore store = new InputComponentStore(mock(BranchConfiguration.class));
+ InputComponentStore store = new InputComponentStore(mock(BranchConfiguration.class), sonarRuntime);
store.put(subModule);
DefaultInputFile fooFile = new TestInputFileBuilder(rootModuleKey, "src/main/java/Foo.java")
}
static class InputComponentStoreTester extends InputComponentStore {
- InputComponentStoreTester() {
- super(mock(BranchConfiguration.class));
+ InputComponentStoreTester(SonarRuntime sonarRuntime) {
+ super(mock(BranchConfiguration.class), sonarRuntime);
+ }
+
+ InputFile addFile(String moduleKey, String relpath, @Nullable String language) {
+ TestInputFileBuilder fileBuilder = new TestInputFileBuilder(moduleKey, relpath);
+ ofNullable(language).ifPresent(fileBuilder::setLanguage);
+ DefaultInputFile file = fileBuilder.build();
+ put(moduleKey, file);
+ return file;
}
- InputFile addFile(String moduleKey, String relpath, String language) {
- DefaultInputFile file = new TestInputFileBuilder(moduleKey, relpath)
- .setLanguage(language)
+ InputFile addFile(String moduleKey, String relPath) {
+ DefaultInputFile file = new TestInputFileBuilder(moduleKey, relPath)
.build();
put(moduleKey, file);
return file;
}
@Test
- public void should_add_languages_per_module_and_globally() throws IOException {
- InputComponentStoreTester tester = new InputComponentStoreTester();
+ public void should_add_languages_per_module_and_globally() {
+ InputComponentStoreTester tester = new InputComponentStoreTester(sonarRuntime);
String mod1Key = "mod1";
tester.addFile(mod1Key, "src/main/java/Foo.java", "java");
}
@Test
- public void should_find_files_per_module_and_globally() throws IOException {
- InputComponentStoreTester tester = new InputComponentStoreTester();
+ public void should_find_files_per_module_and_globally() {
+ InputComponentStoreTester tester = new InputComponentStoreTester(sonarRuntime);
String mod1Key = "mod1";
InputFile mod1File = tester.addFile(mod1Key, "src/main/java/Foo.java", "java");
assertThat(tester.filesByModule(mod2Key)).containsExactly(mod2File);
assertThat(tester.inputFiles()).containsExactlyInAnyOrder(mod1File, mod2File);
}
+
+ @Test
+ public void stores_not_analysed_c_file_count_in_sq_community_edition() {
+ when(sonarRuntime.getEdition()).thenReturn(SonarEdition.COMMUNITY);
+ InputComponentStoreTester underTest = new InputComponentStoreTester(sonarRuntime);
+ String mod1Key = "mod1";
+ underTest.addFile(mod1Key, "src/main/java/Foo.java", "java");
+ underTest.addFile(mod1Key, "src/main/c/file1.c");
+ underTest.addFile(mod1Key, "src/main/c/file2.c");
+ String mod2Key = "mod2";
+ underTest.addFile(mod2Key, "src/main/groovy/Foo.groovy", "groovy");
+ underTest.addFile(mod2Key, "src/main/c/file3.c");
+
+ assertThat(underTest.getNotAnalysedFilesByLanguage()).hasSize(1);
+ assertThat(underTest.getNotAnalysedFilesByLanguage()).containsEntry("C", 3);
+ }
+
+ @Test
+ public void stores_not_analysed_cpp_file_count_in_sq_community_edition() {
+ when(sonarRuntime.getEdition()).thenReturn(SonarEdition.COMMUNITY);
+ InputComponentStoreTester underTest = new InputComponentStoreTester(sonarRuntime);
+ String mod1Key = "mod1";
+ underTest.addFile(mod1Key, "src/main/java/Foo.java", "java");
+ underTest.addFile(mod1Key, "src/main/c/file1.c");
+ underTest.addFile(mod1Key, "src/main/c/file2.cpp");
+ underTest.addFile(mod1Key, "src/main/c/file3.cxx");
+ underTest.addFile(mod1Key, "src/main/c/file4.c++");
+ underTest.addFile(mod1Key, "src/main/c/file5.cc");
+ underTest.addFile(mod1Key, "src/main/c/file6.CPP");
+ String mod2Key = "mod2";
+ underTest.addFile(mod2Key, "src/main/groovy/Foo.groovy", "groovy");
+ underTest.addFile(mod2Key, "src/main/c/file3.cpp");
+
+ assertThat(underTest.getNotAnalysedFilesByLanguage()).hasSize(2);
+ assertThat(underTest.getNotAnalysedFilesByLanguage()).containsEntry("C++", 6);
+ }
+
+ @Test
+ public void does_not_store_not_analysed_file_counts_in_sq_non_community_editions() {
+ when(sonarRuntime.getEdition()).thenReturn(SonarEdition.DEVELOPER);
+ InputComponentStoreTester underTest = new InputComponentStoreTester(sonarRuntime);
+ String mod1Key = "mod1";
+ underTest.addFile(mod1Key, "src/main/java/Foo.java", "java");
+ underTest.addFile(mod1Key, "src/main/java/file1.c");
+ underTest.addFile(mod1Key, "src/main/java/file2.c");
+ String mod2Key = "mod2";
+ underTest.addFile(mod2Key, "src/main/groovy/Foo.groovy", "groovy");
+ underTest.addFile(mod2Key, "src/main/groovy/file4.c");
+
+ assertThat(underTest.getNotAnalysedFilesByLanguage()).isEmpty();
+ }
}
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
+import org.sonar.api.SonarRuntime;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.InputModule;
import org.sonar.api.batch.fs.internal.SensorStrategy;
@Before
public void setUp() throws IOException {
DefaultInputProject root = TestInputFileBuilder.newDefaultInputProject(projectKey, temp.newFolder());
- componentStore = new InputComponentStore(mock(BranchConfiguration.class));
+ componentStore = new InputComponentStore(mock(BranchConfiguration.class), mock(SonarRuntime.class));
}
@Test
import java.util.Scanner;
import javax.annotation.CheckForNull;
import javax.swing.*;
-import javax.swing.UIManager.*;
-import javax.swing.event.*;
-import javax.swing.tree.*;
+import javax.swing.UIManager.LookAndFeelInfo;
+import javax.swing.event.TreeSelectionEvent;
+import javax.swing.event.TreeSelectionListener;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreeSelectionModel;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.sonar.core.util.CloseableIterator;
private JEditorPane cpdTextBlocksEditor;
private JScrollPane significantCodeTab;
private JEditorPane significantCodeEditor;
+ private JScrollPane metadataTab;
+ private JEditorPane metadataEditor;
/**
* Create the application.
updateAdHocRules();
updateQualityProfiles();
updatePlugins();
+ updateMetadata();
}
private void loadComponents() {
}
}
+ private void updateMetadata() {
+ metadataEditor.setText("");
+
+ StringBuilder builder = new StringBuilder();
+ Metadata data = reader.readMetadata();
+ builder.append("Project key: ").append(data.getProjectKey()).append("\n");
+ builder.append("Project version: ").append(data.getProjectVersion()).append("\n");
+ builder.append("Scm revision ID: ").append(data.getScmRevisionId()).append("\n");
+ if (data.getNotAnalyzedFilesByLanguageCount() > 0) {
+ builder.append("Not analyzed files in project:").append("\n");
+ data.getNotAnalyzedFilesByLanguageMap().forEach((key, value) -> builder.append(" ").append(key).append(": ").append(value).append("\n"));
+ }
+ metadataEditor.setText(builder.toString());
+ }
+
private void updateActiveRules() {
activeRuleEditor.setText("");
significantCodeEditor = new JEditorPane();
significantCodeTab.setViewportView(significantCodeEditor);
+ metadataTab = new JScrollPane();
+ tabbedPane.addTab("Metadata", null, metadataTab, null);
+
+ metadataEditor = new JEditorPane();
+ metadataTab.setViewportView(metadataEditor);
+
treeScrollPane = new JScrollPane();
treeScrollPane.setPreferredSize(new Dimension(200, 400));
splitPane.setLeftComponent(treeScrollPane);
int64 forkDate = 19;
+ map<string, int32> not_analyzed_files_by_language = 20;
+
message QProfile {
string key = 1;
string name = 2;