SONAR-11465 Move IssueFilter at project level

sonar-plugin-api/src/main/java/org/sonar/api/scan/issue/filter/IssueFilter.java

 
 import javax.annotation.concurrent.ThreadSafe;
 import org.sonar.api.ExtensionPoint;
-import org.sonar.api.batch.ScannerSide;
+import org.sonar.api.scanner.ScannerSide;
 import org.sonarsource.api.sonarlint.SonarLintSide;
 
 /**
  * @since 5.3
+ * @since 7.6 moved to project container
  * @deprecated since 7.6
  */
 @ScannerSide

sonar-scanner-engine/src/main/java/org/sonar/scanner/issue/DefaultFilterableIssue.java

 package org.sonar.scanner.issue;
 
 import java.util.Date;
-
 import javax.annotation.concurrent.ThreadSafe;
-
 import org.apache.commons.lang.builder.ToStringBuilder;
 import org.apache.commons.lang.builder.ToStringStyle;
-import org.sonar.api.batch.fs.InputModule;
 import org.sonar.api.batch.fs.TextRange;
-import org.sonar.api.batch.fs.internal.AbstractProjectOrModule;
+import org.sonar.api.batch.fs.internal.DefaultInputProject;
 import org.sonar.api.batch.fs.internal.DefaultTextPointer;
 import org.sonar.api.batch.fs.internal.DefaultTextRange;
 import org.sonar.api.rule.RuleKey;
   private final Issue rawIssue;
   private final ProjectAnalysisInfo projectAnalysisInfo;
   private final String componentKey;
-  private AbstractProjectOrModule module;
+  private DefaultInputProject project;
 
-  public DefaultFilterableIssue(InputModule module, ProjectAnalysisInfo projectAnalysisInfo, Issue rawIssue, String componentKey) {
-    this.module = (AbstractProjectOrModule) module;
+  public DefaultFilterableIssue(DefaultInputProject project, ProjectAnalysisInfo projectAnalysisInfo, Issue rawIssue, String componentKey) {
+    this.project = project;
     this.projectAnalysisInfo = projectAnalysisInfo;
     this.rawIssue = rawIssue;
     this.componentKey = componentKey;
 
   @Override
   public String projectKey() {
-    return module.key();
+    return project.key();
   }
 
   @Override

sonar-scanner-engine/src/main/java/org/sonar/scanner/issue/ModuleIssueFilters.java → sonar-scanner-engine/src/main/java/org/sonar/scanner/issue/IssueFilters.java

  */
 package org.sonar.scanner.issue;
 
-import org.sonar.api.batch.fs.InputModule;
+import org.sonar.api.batch.fs.internal.DefaultInputProject;
 import org.sonar.api.scan.issue.filter.FilterableIssue;
 import org.sonar.api.scan.issue.filter.IssueFilter;
 import org.sonar.api.scan.issue.filter.IssueFilterChain;
  * @deprecated since 7.6, {@link IssueFilter} is deprecated
  */
 @Deprecated
-public class ModuleIssueFilters {
+public class IssueFilters {
   private final IssueFilterChain filterChain;
-  private final InputModule module;
+  private final DefaultInputProject project;
   private final ProjectAnalysisInfo projectAnalysisInfo;
 
-  public ModuleIssueFilters(InputModule module, ProjectAnalysisInfo projectAnalysisInfo, IssueFilter[] exclusionFilters) {
-    this.module = module;
+  public IssueFilters(DefaultInputProject project, ProjectAnalysisInfo projectAnalysisInfo, IssueFilter[] exclusionFilters) {
+    this.project = project;
     this.filterChain = new DefaultIssueFilterChain(exclusionFilters);
     this.projectAnalysisInfo = projectAnalysisInfo;
   }
 
-  public ModuleIssueFilters(InputModule module, ProjectAnalysisInfo projectAnalysisInfo) {
-    this(module, projectAnalysisInfo, new IssueFilter[0]);
+  public IssueFilters(DefaultInputProject project, ProjectAnalysisInfo projectAnalysisInfo) {
+    this(project, projectAnalysisInfo, new IssueFilter[0]);
   }
 
   public boolean accept(String componentKey, ScannerReport.Issue rawIssue) {
-    FilterableIssue fIssue = new DefaultFilterableIssue(module, projectAnalysisInfo, rawIssue, componentKey);
+    FilterableIssue fIssue = new DefaultFilterableIssue(project, projectAnalysisInfo, rawIssue, componentKey);
     return filterChain.accept(fIssue);
   }
 

sonar-scanner-engine/src/main/java/org/sonar/scanner/issue/ModuleIssues.java → sonar-scanner-engine/src/main/java/org/sonar/scanner/issue/IssuePublisher.java

  * Initialize the issues raised during scan.
  */
 @ThreadSafe
-public class ModuleIssues {
+public class IssuePublisher {
 
   private final ActiveRules activeRules;
-  private final ModuleIssueFilters filters;
+  private final IssueFilters filters;
   private final ReportPublisher reportPublisher;
 
-  public ModuleIssues(ActiveRules activeRules, ModuleIssueFilters filters, ReportPublisher reportPublisher) {
+  public IssuePublisher(ActiveRules activeRules, IssueFilters filters, ReportPublisher reportPublisher) {
     this.activeRules = activeRules;
     this.filters = filters;
     this.reportPublisher = reportPublisher;

sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ModuleScanContainer.java

 import org.sonar.scanner.bootstrap.ExtensionInstaller;
 import org.sonar.scanner.bootstrap.SensorExtensionDictionnary;
 import org.sonar.scanner.deprecated.perspectives.ScannerPerspectives;
-import org.sonar.scanner.issue.ModuleIssueFilters;
-import org.sonar.scanner.issue.ModuleIssues;
-import org.sonar.scanner.phases.ModuleCoverageExclusions;
 import org.sonar.scanner.phases.SensorsExecutor;
 import org.sonar.scanner.scan.filesystem.DefaultModuleFileSystem;
 import org.sonar.scanner.scan.filesystem.ModuleInputComponentStore;
       DefaultSensorStorage.class,
       DefaultSensorContext.class,
       SensorExtensionDictionnary.class,
-      ModuleIssueFilters.class,
-      ModuleCoverageExclusions.class,
-
-      // issues
-      ModuleIssues.class,
 
       // Perspectives
       ScannerPerspectives.class,

sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ProjectScanContainer.java

 import org.sonar.scanner.deprecated.test.TestableBuilder;
 import org.sonar.scanner.issue.DefaultProjectIssues;
 import org.sonar.scanner.issue.IssueCache;
+import org.sonar.scanner.issue.IssueFilters;
+import org.sonar.scanner.issue.IssuePublisher;
 import org.sonar.scanner.issue.ignore.EnforceIssuesFilter;
 import org.sonar.scanner.issue.ignore.IgnoreIssuesFilter;
 import org.sonar.scanner.issue.ignore.pattern.IssueExclusionPatternInitializer;
       DefaultProjectIssues.class,
       IssueTransition.class,
       NoSonarFilter.class,
+      IssueFilters.class,
+      IssuePublisher.class,
+
 
       // metrics
       DefaultMetricFinder.class,

sonar-scanner-engine/src/main/java/org/sonar/scanner/sensor/DefaultSensorStorage.java

 import org.sonar.duplications.block.Block;
 import org.sonar.duplications.internal.pmd.PmdBlockChunker;
 import org.sonar.scanner.cpd.index.SonarCpdBlockIndex;
-import org.sonar.scanner.issue.ModuleIssues;
+import org.sonar.scanner.issue.IssuePublisher;
 import org.sonar.scanner.protocol.Constants;
 import org.sonar.scanner.protocol.output.FileStructure;
 import org.sonar.scanner.protocol.output.ScannerReport;
   }
 
   private final MetricFinder metricFinder;
-  private final ModuleIssues moduleIssues;
+  private final IssuePublisher moduleIssues;
   private final ReportPublisher reportPublisher;
   private final MeasureCache measureCache;
   private final SonarCpdBlockIndex index;
   private final BranchConfiguration branchConfiguration;
   private final Set<String> alreadyLogged = new HashSet<>();
 
-  public DefaultSensorStorage(MetricFinder metricFinder, ModuleIssues moduleIssues, Configuration settings,
-    ReportPublisher reportPublisher, MeasureCache measureCache, SonarCpdBlockIndex index,
-    ContextPropertiesCache contextPropertiesCache, ScannerMetrics scannerMetrics, BranchConfiguration branchConfiguration) {
+  public DefaultSensorStorage(MetricFinder metricFinder, IssuePublisher moduleIssues, Configuration settings,
+                              ReportPublisher reportPublisher, MeasureCache measureCache, SonarCpdBlockIndex index,
+                              ContextPropertiesCache contextPropertiesCache, ScannerMetrics scannerMetrics, BranchConfiguration branchConfiguration) {
     this.metricFinder = metricFinder;
     this.moduleIssues = moduleIssues;
     this.settings = settings;

sonar-scanner-engine/src/test/java/org/sonar/scanner/DefaultFileLinesContextTest.java

  */
 package org.sonar.scanner;
 
-import java.io.File;
+import java.util.List;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
+import org.mockito.ArgumentCaptor;
+import org.sonar.api.batch.fs.internal.DefaultInputFile;
 import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.measure.MetricFinder;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import org.sonar.api.batch.sensor.internal.SensorStorage;
 import org.sonar.api.batch.sensor.measure.internal.DefaultMeasure;
 import org.sonar.api.measures.CoreMetrics;
 import org.sonar.scanner.scan.measure.MeasureCache;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 import static org.sonar.api.measures.CoreMetrics.EXECUTABLE_LINES_DATA_KEY;
 import static org.sonar.api.measures.CoreMetrics.NCLOC_DATA_KEY;
 
   private DefaultFileLinesContext fileLineMeasures;
 
-  private SensorContextTester sensorContextTester;
   private MeasureCache measureCache;
+  private SensorStorage sensorStorage;
+  private DefaultInputFile file;
 
   @Before
   public void setUp() throws Exception {
-    sensorContextTester = SensorContextTester.create(temp.newFolder());
     MetricFinder metricFinder = mock(MetricFinder.class);
     org.sonar.api.batch.measure.Metric<String> hitsMetric = mock(org.sonar.api.batch.measure.Metric.class);
     when(hitsMetric.valueType()).thenReturn(String.class);
     when(metricFinder.<String>findByKey(CoreMetrics.NCLOC_DATA_KEY)).thenReturn(CoreMetrics.NCLOC_DATA);
     when(metricFinder.<String>findByKey(CoreMetrics.EXECUTABLE_LINES_DATA_KEY)).thenReturn(CoreMetrics.EXECUTABLE_LINES_DATA);
     measureCache = mock(MeasureCache.class);
-    fileLineMeasures = new DefaultFileLinesContext(sensorContextTester, new TestInputFileBuilder("foo", "src/foo.php").initMetadata("Foo\nbar\nbiz").build(), metricFinder,
+    sensorStorage = mock(SensorStorage.class);
+    file = new TestInputFileBuilder("foo", "src/foo.php").initMetadata("Foo\nbar\nbiz").build();
+    fileLineMeasures = new DefaultFileLinesContext(sensorStorage, file, metricFinder,
       measureCache);
   }
 
 
     assertThat(fileLineMeasures.toString()).isEqualTo("DefaultFileLinesContext{map={hits={1=2, 3=0}}}");
 
-    assertThat(sensorContextTester.measure("foo:src/foo.php", HITS_METRIC_KEY).value()).isEqualTo("1=2;3=0");
+    ArgumentCaptor<DefaultMeasure> captor = ArgumentCaptor.forClass(DefaultMeasure.class);
+    verify(sensorStorage).store(captor.capture());
+
+    DefaultMeasure measure = captor.getValue();
+    assertThat(measure.inputComponent()).isEqualTo(file);
+    assertThat(measure.metric().key()).isEqualTo(HITS_METRIC_KEY);
+    assertThat(measure.value()).isEqualTo("1=2;3=0");
   }
 
   @Test
     fileLineMeasures.setIntValue(EXECUTABLE_LINES_DATA_KEY, 2, 1);
     fileLineMeasures.save();
 
-    assertThat(sensorContextTester.measure("foo:src/foo.php", NCLOC_DATA_KEY).value()).isEqualTo("2=1");
-    assertThat(sensorContextTester.measure("foo:src/foo.php", EXECUTABLE_LINES_DATA_KEY).value()).isEqualTo("2=1");
+    ArgumentCaptor<DefaultMeasure> captor = ArgumentCaptor.forClass(DefaultMeasure.class);
+    verify(sensorStorage, times(2)).store(captor.capture());
+
+    List<DefaultMeasure> measures = captor.getAllValues();
+    assertThat(measures).extracting(DefaultMeasure::inputComponent, m -> m.metric().key(), DefaultMeasure::value)
+      .containsExactlyInAnyOrder(tuple(file, NCLOC_DATA_KEY, "2=1"),
+        tuple(file, EXECUTABLE_LINES_DATA_KEY, "2=1"));
   }
 
   @Test
     fileLineMeasures.setIntValue(BRANCHES_METRIC_KEY, 3, 4);
     fileLineMeasures.save();
 
-    assertThat(sensorContextTester.measure("foo:src/foo.php", HITS_METRIC_KEY).value()).isEqualTo("1=2;3=4");
-    assertThat(sensorContextTester.measure("foo:src/foo.php", AUTHOR_METRIC_KEY).value()).isEqualTo("1=simon;3=evgeny");
-    assertThat(sensorContextTester.measure("foo:src/foo.php", BRANCHES_METRIC_KEY).value()).isEqualTo("1=2;3=4");
+    ArgumentCaptor<DefaultMeasure> captor = ArgumentCaptor.forClass(DefaultMeasure.class);
+    verify(sensorStorage, times(3)).store(captor.capture());
+
+    List<DefaultMeasure> measures = captor.getAllValues();
+    assertThat(measures).extracting(DefaultMeasure::inputComponent, m -> m.metric().key(), DefaultMeasure::value)
+      .containsExactlyInAnyOrder(tuple(file, HITS_METRIC_KEY, "1=2;3=4"),
+        tuple(file, AUTHOR_METRIC_KEY, "1=simon;3=evgeny"),
+        tuple(file, BRANCHES_METRIC_KEY, "1=2;3=4"));
   }
 
   @Test(expected = UnsupportedOperationException.class)

sonar-scanner-engine/src/test/java/org/sonar/scanner/issue/DefaultFilterableIssueTest.java

 import java.util.Date;
 import org.junit.Before;
 import org.junit.Test;
-import org.sonar.api.batch.fs.internal.DefaultInputModule;
+import org.sonar.api.batch.fs.internal.DefaultInputProject;
 import org.sonar.scanner.ProjectAnalysisInfo;
 import org.sonar.scanner.protocol.Constants.Severity;
 import org.sonar.scanner.protocol.output.ScannerReport.Issue;
 
 public class DefaultFilterableIssueTest {
   private DefaultFilterableIssue issue;
-  private DefaultInputModule mockedProject;
+  private DefaultInputProject mockedProject;
   private ProjectAnalysisInfo projectAnalysisInfo;
   private String componentKey;
   private Issue rawIssue;
 
   @Before
   public void setUp() {
-    mockedProject = mock(DefaultInputModule.class);
+    mockedProject = mock(DefaultInputProject.class);
     projectAnalysisInfo = mock(ProjectAnalysisInfo.class);
     componentKey = "component";
   }

sonar-scanner-engine/src/test/java/org/sonar/scanner/issue/ModuleIssuesTest.java → sonar-scanner-engine/src/test/java/org/sonar/scanner/issue/IssuePublisherTest.java

 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
-public class ModuleIssuesTest {
+public class IssuePublisherTest {
 
   static final RuleKey SQUID_RULE_KEY = RuleKey.of("squid", "AvoidCycle");
   static final String SQUID_RULE_NAME = "Avoid Cycle";
   public TemporaryFolder temp = new TemporaryFolder();
 
   @Mock
-  ModuleIssueFilters filters;
+  IssueFilters filters;
 
   ActiveRulesBuilder activeRulesBuilder = new ActiveRulesBuilder();
   RulesBuilder ruleBuilder = new RulesBuilder();
 
-  ModuleIssues moduleIssues;
+  IssuePublisher moduleIssues;
 
   DefaultInputFile file = new TestInputFileBuilder("foo", "src/Foo.php").initMetadata("Foo\nBar\nBiz\n").build();
   ReportPublisher reportPublisher = mock(ReportPublisher.class, RETURNS_DEEP_STUBS);
   }
 
   /**
-   * Every rules and active rules has to be added in builders before creating ModuleIssues
+   * Every rules and active rules has to be added in builders before creating IssuePublisher
    */
   private void initModuleIssues() {
-    moduleIssues = new ModuleIssues(activeRulesBuilder.build(), filters, reportPublisher);
+    moduleIssues = new IssuePublisher(activeRulesBuilder.build(), filters, reportPublisher);
   }
 
 }

sonar-scanner-engine/src/test/java/org/sonar/scanner/sensor/DefaultSensorStorageTest.java

 import org.sonar.api.utils.KeyValueFormat;
 import org.sonar.core.metric.ScannerMetrics;
 import org.sonar.scanner.cpd.index.SonarCpdBlockIndex;
-import org.sonar.scanner.issue.ModuleIssues;
+import org.sonar.scanner.issue.IssuePublisher;
 import org.sonar.scanner.protocol.output.FileStructure;
 import org.sonar.scanner.protocol.output.ScannerReportWriter;
 import org.sonar.scanner.report.ReportPublisher;
 
   private DefaultSensorStorage underTest;
   private MapSettings settings;
-  private ModuleIssues moduleIssues;
+  private IssuePublisher moduleIssues;
   private MeasureCache measureCache;
   private ScannerReportWriter reportWriter;
   private ContextPropertiesCache contextPropertiesCache = new ContextPropertiesCache();
     when(metricFinder.<Integer>findByKey(CoreMetrics.LINES_TO_COVER_KEY)).thenReturn(CoreMetrics.LINES_TO_COVER);
 
     settings = new MapSettings();
-    moduleIssues = mock(ModuleIssues.class);
+    moduleIssues = mock(IssuePublisher.class);
     measureCache = mock(MeasureCache.class);
 
     ReportPublisher reportPublisher = mock(ReportPublisher.class);