diff options
11 files changed, 251 insertions, 101 deletions
diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/EnforceIssuesFilter.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/EnforceIssuesFilter.java index 1a5d89b9a2d..cd443178177 100644 --- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/EnforceIssuesFilter.java +++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/EnforceIssuesFilter.java @@ -22,19 +22,45 @@ package org.sonar.plugins.core.issue.ignore; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.sonar.api.issue.Issue; +import org.sonar.api.issue.batch.IssueFilter; +import org.sonar.api.issue.batch.IssueFilterChain; import org.sonar.plugins.core.issue.ignore.pattern.InclusionPatternInitializer; import org.sonar.plugins.core.issue.ignore.pattern.IssuePattern; -public final class EnforceIssuesFilter extends IssuesFilterBase { +public class EnforceIssuesFilter implements IssueFilter { + + private InclusionPatternInitializer patternInitializer; private static final Logger LOG = LoggerFactory.getLogger(EnforceIssuesFilter.class); public EnforceIssuesFilter(InclusionPatternInitializer patternInitializer) { - super(patternInitializer); + this.patternInitializer = patternInitializer; } @Override - protected void logExclusion(Issue issue, IssuePattern pattern) { - LOG.debug("Issue {} ignored by inclusion pattern {}", issue, pattern); + public boolean accept(Issue issue, IssueFilterChain chain) { + boolean atLeastOneRuleMatched = false; + boolean atLeastOnePatternFullyMatched = false; + IssuePattern matchingPattern = null; + + for (IssuePattern pattern : patternInitializer.getMulticriteriaPatterns()) { + if (pattern.getRulePattern().match(issue.ruleKey().toString())) { + atLeastOneRuleMatched = true; + String pathForComponent = patternInitializer.getPathForComponent(issue.componentKey()); + if (pathForComponent != null && pattern.getResourcePattern().match(pathForComponent)) { + atLeastOnePatternFullyMatched = true; + matchingPattern = pattern; + } + } + } + + if (atLeastOneRuleMatched) { + if (atLeastOnePatternFullyMatched) { + LOG.debug("Issue {} enforced by pattern {}", issue, matchingPattern); + } + return atLeastOnePatternFullyMatched; + } else { + return chain.accept(issue); + } } } diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/IgnoreIssuesFilter.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/IgnoreIssuesFilter.java index 7cc8a7f7014..d49369dddae 100644 --- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/IgnoreIssuesFilter.java +++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/IgnoreIssuesFilter.java @@ -22,19 +22,41 @@ package org.sonar.plugins.core.issue.ignore; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.sonar.api.issue.Issue; +import org.sonar.api.issue.batch.IssueFilter; +import org.sonar.api.issue.batch.IssueFilterChain; import org.sonar.plugins.core.issue.ignore.pattern.ExclusionPatternInitializer; import org.sonar.plugins.core.issue.ignore.pattern.IssuePattern; +import org.sonar.plugins.core.issue.ignore.pattern.PatternMatcher; -public final class IgnoreIssuesFilter extends IssuesFilterBase { +public class IgnoreIssuesFilter implements IssueFilter { + + private PatternMatcher patternMatcher; private static final Logger LOG = LoggerFactory.getLogger(IgnoreIssuesFilter.class); public IgnoreIssuesFilter(ExclusionPatternInitializer patternInitializer) { - super(patternInitializer); + this.patternMatcher = patternInitializer.getPatternMatcher(); } @Override - protected void logExclusion(Issue issue, IssuePattern pattern) { + public boolean accept(Issue issue, IssueFilterChain chain) { + if (hasMatchFor(issue)) { + return false; + } else { + return chain.accept(issue); + } + } + + private boolean hasMatchFor(Issue issue) { + IssuePattern pattern = patternMatcher.getMatchingPattern(issue); + if (pattern != null) { + logExclusion(issue, pattern); + return true; + } + return false; + } + + private void logExclusion(Issue issue, IssuePattern pattern) { LOG.debug("Issue {} ignored by exclusion pattern {}", issue, pattern); } } diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/IssuesFilterBase.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/IssuesFilterBase.java deleted file mode 100644 index 7bb614ed6db..00000000000 --- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/IssuesFilterBase.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * SonarQube, open source software quality management tool. - * Copyright (C) 2008-2013 SonarSource - * mailto:contact AT sonarsource DOT com - * - * SonarQube 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. - * - * SonarQube 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 this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ -package org.sonar.plugins.core.issue.ignore; - -import org.sonar.plugins.core.issue.ignore.pattern.IssuePattern; - -import org.sonar.plugins.core.issue.ignore.pattern.PatternMatcher; -import org.sonar.plugins.core.issue.ignore.pattern.AbstractPatternInitializer; -import org.sonar.api.issue.Issue; -import org.sonar.api.issue.IssueFilter; - -public abstract class IssuesFilterBase implements IssueFilter { - - private PatternMatcher patternMatcher; - - protected IssuesFilterBase(AbstractPatternInitializer patternInitializer) { - this.patternMatcher = patternInitializer.getPatternMatcher(); - } - - @Override - public boolean accept(Issue issue) { - IssuePattern pattern = patternMatcher.getMatchingPattern(issue); - if (pattern != null) { - logExclusion(issue, pattern); - return false; - } - return true; - } - - protected abstract void logExclusion(Issue issue, IssuePattern pattern); -} diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/AbstractPatternInitializer.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/AbstractPatternInitializer.java index 5ce56ec9f0f..6dffb6544d6 100644 --- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/AbstractPatternInitializer.java +++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/AbstractPatternInitializer.java @@ -21,14 +21,14 @@ package org.sonar.plugins.core.issue.ignore.pattern; import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.Lists; +import org.apache.commons.lang.StringUtils; +import org.sonar.api.BatchExtension; +import org.sonar.api.config.Settings; +import org.sonar.plugins.core.issue.ignore.IgnoreIssuesConfiguration; import java.util.List; -import org.apache.commons.lang.StringUtils; -import org.sonar.plugins.core.issue.ignore.IgnoreIssuesConfiguration; import static com.google.common.base.Objects.firstNonNull; -import org.sonar.api.BatchExtension; -import org.sonar.api.config.Settings; public abstract class AbstractPatternInitializer implements BatchExtension { @@ -36,11 +36,8 @@ public abstract class AbstractPatternInitializer implements BatchExtension { private List<IssuePattern> multicriteriaPatterns; - private PatternMatcher patternMatcher; - protected AbstractPatternInitializer(Settings settings) { this.settings = settings; - this.patternMatcher = new PatternMatcher(); initPatterns(); } @@ -48,10 +45,6 @@ public abstract class AbstractPatternInitializer implements BatchExtension { return settings; } - public PatternMatcher getPatternMatcher() { - return patternMatcher; - } - public List<IssuePattern> getMulticriteriaPatterns() { return multicriteriaPatterns; } @@ -64,15 +57,7 @@ public abstract class AbstractPatternInitializer implements BatchExtension { return ! multicriteriaPatterns.isEmpty(); } - public void initializePatternsForPath(String relativePath, String componentKey) { - for (IssuePattern pattern: getMulticriteriaPatterns()) { - if (shouldAddPatternIfMatch(pattern.matchResource(relativePath))) { - getPatternMatcher().addPatternForComponent(componentKey, pattern); - } - } - } - - protected abstract boolean shouldAddPatternIfMatch(boolean match); + public abstract void initializePatternsForPath(String relativePath, String componentKey); @VisibleForTesting protected final void initPatterns() { diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/ExclusionPatternInitializer.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/ExclusionPatternInitializer.java index 06ebd7c276f..c19352b32b7 100644 --- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/ExclusionPatternInitializer.java +++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/ExclusionPatternInitializer.java @@ -33,9 +33,11 @@ public class ExclusionPatternInitializer extends AbstractPatternInitializer { private List<IssuePattern> blockPatterns; private List<IssuePattern> allFilePatterns; + private PatternMatcher patternMatcher; public ExclusionPatternInitializer(Settings settings) { super(settings); + patternMatcher = new PatternMatcher(); } @Override @@ -43,9 +45,17 @@ public class ExclusionPatternInitializer extends AbstractPatternInitializer { return IgnoreIssuesConfiguration.PATTERNS_MULTICRITERIA_EXCLUSION_KEY; } + public PatternMatcher getPatternMatcher() { + return patternMatcher; + } + @Override - protected boolean shouldAddPatternIfMatch(boolean match) { - return match; + public void initializePatternsForPath(String relativePath, String componentKey) { + for (IssuePattern pattern: getMulticriteriaPatterns()) { + if (pattern.matchResource(relativePath)) { + getPatternMatcher().addPatternForComponent(componentKey, pattern); + } + } } @Override diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/InclusionPatternInitializer.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/InclusionPatternInitializer.java index 292fc33d2df..57dd0086c03 100644 --- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/InclusionPatternInitializer.java +++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/ignore/pattern/InclusionPatternInitializer.java @@ -20,13 +20,19 @@ package org.sonar.plugins.core.issue.ignore.pattern; +import com.google.common.collect.Maps; import org.sonar.api.config.Settings; import org.sonar.plugins.core.issue.ignore.IgnoreIssuesConfiguration; +import java.util.Map; + public class InclusionPatternInitializer extends AbstractPatternInitializer { + private Map<String, String> pathForComponent; + public InclusionPatternInitializer(Settings settings) { super(settings); + pathForComponent = Maps.newHashMap(); } @Override @@ -35,8 +41,11 @@ public class InclusionPatternInitializer extends AbstractPatternInitializer { } @Override - protected boolean shouldAddPatternIfMatch(boolean match) { - return ! match; + public void initializePatternsForPath(String relativePath, String componentKey) { + pathForComponent.put(componentKey, relativePath); } + public String getPathForComponent(String componentKey) { + return pathForComponent.get(componentKey); + } } diff --git a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/EnforceIssuesFilterTest.java b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/EnforceIssuesFilterTest.java new file mode 100644 index 00000000000..3cba13dbd78 --- /dev/null +++ b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/EnforceIssuesFilterTest.java @@ -0,0 +1,150 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2013 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube 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. + * + * SonarQube 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 this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +package org.sonar.plugins.core.issue.ignore; + +import com.google.common.collect.ImmutableList; +import org.junit.Before; +import org.junit.Test; +import org.sonar.api.issue.Issue; +import org.sonar.api.issue.batch.IssueFilterChain; +import org.sonar.api.rule.RuleKey; +import org.sonar.api.utils.WildcardPattern; +import org.sonar.plugins.core.issue.ignore.pattern.InclusionPatternInitializer; +import org.sonar.plugins.core.issue.ignore.pattern.IssuePattern; + +import static org.fest.assertions.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +public class EnforceIssuesFilterTest { + + private InclusionPatternInitializer exclusionPatternInitializer; + private EnforceIssuesFilter ignoreFilter; + private Issue issue; + private IssueFilterChain chain; + + @Before + public void init() { + exclusionPatternInitializer = mock(InclusionPatternInitializer.class); + issue = mock(Issue.class); + chain = mock(IssueFilterChain.class); + when(chain.accept(issue)).thenReturn(true); + + ignoreFilter = new EnforceIssuesFilter(exclusionPatternInitializer); + } + + @Test + public void shouldPassToChainIfNoConfiguredPatterns() { + assertThat(ignoreFilter.accept(issue, chain)).isTrue(); + verify(chain).accept(issue); + } + + @Test + public void shouldPassToChainIfRuleDoesNotMatch() { + String rule = "rule"; + RuleKey ruleKey = mock(RuleKey.class); + when(ruleKey.toString()).thenReturn(rule); + when(issue.ruleKey()).thenReturn(ruleKey); + + IssuePattern matching = mock(IssuePattern.class); + WildcardPattern rulePattern = mock(WildcardPattern.class); + when(matching.getRulePattern()).thenReturn(rulePattern); + when(rulePattern.match(rule)).thenReturn(false); + when(exclusionPatternInitializer.getMulticriteriaPatterns()).thenReturn(ImmutableList.of(matching)); + + assertThat(ignoreFilter.accept(issue, chain)).isTrue(); + verify(chain).accept(issue); + } + + @Test + public void shouldAcceptIssueIfFullyMatched() { + String rule = "rule"; + String path = "org/sonar/api/Issue.java"; + String componentKey = "org.sonar.api.Issue"; + RuleKey ruleKey = mock(RuleKey.class); + when(ruleKey.toString()).thenReturn(rule); + when(issue.ruleKey()).thenReturn(ruleKey); + when(issue.componentKey()).thenReturn(componentKey); + + IssuePattern matching = mock(IssuePattern.class); + WildcardPattern rulePattern = mock(WildcardPattern.class); + when(matching.getRulePattern()).thenReturn(rulePattern); + when(rulePattern.match(rule)).thenReturn(true); + WildcardPattern pathPattern = mock(WildcardPattern.class); + when(matching.getResourcePattern()).thenReturn(pathPattern); + when(pathPattern.match(path)).thenReturn(true); + when(exclusionPatternInitializer.getMulticriteriaPatterns()).thenReturn(ImmutableList.of(matching)); + when(exclusionPatternInitializer.getPathForComponent(componentKey)).thenReturn(path); + + assertThat(ignoreFilter.accept(issue, chain)).isTrue(); + verifyZeroInteractions(chain); + } + + @Test + public void shouldRefuseIssueIfRuleMatchesButNotPath() { + String rule = "rule"; + String path = "org/sonar/api/Issue.java"; + String componentKey = "org.sonar.api.Issue"; + RuleKey ruleKey = mock(RuleKey.class); + when(ruleKey.toString()).thenReturn(rule); + when(issue.ruleKey()).thenReturn(ruleKey); + when(issue.componentKey()).thenReturn(componentKey); + + IssuePattern matching = mock(IssuePattern.class); + WildcardPattern rulePattern = mock(WildcardPattern.class); + when(matching.getRulePattern()).thenReturn(rulePattern); + when(rulePattern.match(rule)).thenReturn(true); + WildcardPattern pathPattern = mock(WildcardPattern.class); + when(matching.getResourcePattern()).thenReturn(pathPattern); + when(pathPattern.match(path)).thenReturn(false); + when(exclusionPatternInitializer.getMulticriteriaPatterns()).thenReturn(ImmutableList.of(matching)); + when(exclusionPatternInitializer.getPathForComponent(componentKey)).thenReturn(path); + + assertThat(ignoreFilter.accept(issue, chain)).isFalse(); + verifyZeroInteractions(chain); + } + + @Test + public void shouldRefuseIssueIfRuleMatchesAndPathUnknown() { + String rule = "rule"; + String path = "org/sonar/api/Issue.java"; + String componentKey = "org.sonar.api.Issue"; + RuleKey ruleKey = mock(RuleKey.class); + when(ruleKey.toString()).thenReturn(rule); + when(issue.ruleKey()).thenReturn(ruleKey); + when(issue.componentKey()).thenReturn(componentKey); + + IssuePattern matching = mock(IssuePattern.class); + WildcardPattern rulePattern = mock(WildcardPattern.class); + when(matching.getRulePattern()).thenReturn(rulePattern); + when(rulePattern.match(rule)).thenReturn(true); + WildcardPattern pathPattern = mock(WildcardPattern.class); + when(matching.getResourcePattern()).thenReturn(pathPattern); + when(pathPattern.match(path)).thenReturn(false); + when(exclusionPatternInitializer.getMulticriteriaPatterns()).thenReturn(ImmutableList.of(matching)); + when(exclusionPatternInitializer.getPathForComponent(componentKey)).thenReturn(null); + + assertThat(ignoreFilter.accept(issue, chain)).isFalse(); + verifyZeroInteractions(chain); + } +} diff --git a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/IssuesFilterTest.java b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/IgnoreIssuesFilterTest.java index a04f02928a4..b582c101e03 100644 --- a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/IssuesFilterTest.java +++ b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/IgnoreIssuesFilterTest.java @@ -23,8 +23,8 @@ package org.sonar.plugins.core.issue.ignore; import org.junit.Before; import org.junit.Test; import org.sonar.api.issue.Issue; +import org.sonar.api.issue.batch.IssueFilterChain; import org.sonar.plugins.core.issue.ignore.pattern.ExclusionPatternInitializer; -import org.sonar.plugins.core.issue.ignore.pattern.InclusionPatternInitializer; import org.sonar.plugins.core.issue.ignore.pattern.IssuePattern; import org.sonar.plugins.core.issue.ignore.pattern.PatternMatcher; @@ -32,45 +32,37 @@ import static org.fest.assertions.Assertions.assertThat; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -public class IssuesFilterTest { +public class IgnoreIssuesFilterTest { - private InclusionPatternInitializer inclusionPatternInitializer; private ExclusionPatternInitializer exclusionPatternInitializer; - private PatternMatcher inclusionPatternMatcher; private PatternMatcher exclusionPatternMatcher; private IgnoreIssuesFilter ignoreFilter; - private EnforceIssuesFilter enforceFilter; private Issue issue; + private IssueFilterChain chain; @Before public void init() { exclusionPatternMatcher = mock(PatternMatcher.class); exclusionPatternInitializer = mock(ExclusionPatternInitializer.class); when(exclusionPatternInitializer.getPatternMatcher()).thenReturn(exclusionPatternMatcher); - inclusionPatternMatcher = mock(PatternMatcher.class); - inclusionPatternInitializer = mock(InclusionPatternInitializer.class); - when(inclusionPatternInitializer.getPatternMatcher()).thenReturn(inclusionPatternMatcher); issue = mock(Issue.class); + chain = mock(IssueFilterChain.class); + when(chain.accept(issue)).thenReturn(true); ignoreFilter = new IgnoreIssuesFilter(exclusionPatternInitializer); - enforceFilter = new EnforceIssuesFilter(inclusionPatternInitializer); } @Test - public void shouldAcceptIfMatcherHasNoPatternForIssue() { - when(inclusionPatternMatcher.getMatchingPattern(issue)).thenReturn(null); + public void shouldPassToChainIfMatcherHasNoPatternForIssue() { when(exclusionPatternMatcher.getMatchingPattern(issue)).thenReturn(null); - assertThat(ignoreFilter.accept(issue)).isTrue(); - assertThat(enforceFilter.accept(issue)).isTrue(); + assertThat(ignoreFilter.accept(issue, chain)).isTrue(); } @Test - public void shouldNotAcceptIfMatcherHasPatternForIssue() { - when(inclusionPatternMatcher.getMatchingPattern(issue)).thenReturn(mock(IssuePattern.class)); + public void shouldAcceptOrRefuseIfMatcherHasPatternForIssue() { when(exclusionPatternMatcher.getMatchingPattern(issue)).thenReturn(mock(IssuePattern.class)); - assertThat(ignoreFilter.accept(issue)).isFalse(); - assertThat(enforceFilter.accept(issue)).isFalse(); + assertThat(ignoreFilter.accept(issue, chain)).isFalse(); } } diff --git a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/pattern/InclusionPatternInitializerTest.java b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/pattern/InclusionPatternInitializerTest.java index a0ca422d793..ce26da2df68 100644 --- a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/pattern/InclusionPatternInitializerTest.java +++ b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/ignore/pattern/InclusionPatternInitializerTest.java @@ -44,7 +44,6 @@ public class InclusionPatternInitializerTest { public void testNoConfiguration() { patternsInitializer.initPatterns(); assertThat(patternsInitializer.hasConfiguredPatterns()).isFalse(); - assertThat(patternsInitializer.getMulticriteriaPatterns().size()).isEqualTo(0); } @Test @@ -66,9 +65,9 @@ public class InclusionPatternInitializerTest { patternsInitializer.initializePatternsForPath("org/foo/Baz.java", "org.foo.Baz"); patternsInitializer.initializePatternsForPath("org/foo/Hello.java", "org.foo.Hello"); - assertThat(patternsInitializer.getPatternMatcher().getPatternsForComponent("org.foo.Bar")).hasSize(1); - assertThat(patternsInitializer.getPatternMatcher().getPatternsForComponent("org.foo.Baz")).hasSize(2); - assertThat(patternsInitializer.getPatternMatcher().getPatternsForComponent("org.foo.Hello")).hasSize(1); + assertThat(patternsInitializer.getPathForComponent("org.foo.Bar")).isEqualTo("org/foo/Bar.java"); + assertThat(patternsInitializer.getPathForComponent("org.foo.Baz")).isEqualTo("org/foo/Baz.java"); + assertThat(patternsInitializer.getPathForComponent("org.foo.Hello")).isEqualTo("org/foo/Hello.java"); } } diff --git a/sonar-batch/src/main/java/org/sonar/batch/issue/IssueFilters.java b/sonar-batch/src/main/java/org/sonar/batch/issue/IssueFilters.java index dc79211d39c..faab6ccdfda 100644 --- a/sonar-batch/src/main/java/org/sonar/batch/issue/IssueFilters.java +++ b/sonar-batch/src/main/java/org/sonar/batch/issue/IssueFilters.java @@ -41,6 +41,10 @@ public class IssueFilters implements BatchExtension { this.filters = filters; } + public IssueFilters(ViolationFilters deprecatedFilters, DeprecatedViolations deprecatedViolations, IssueFilter[] filters) { + this(deprecatedFilters, deprecatedViolations, new org.sonar.api.issue.IssueFilter[0], filters); + } + public IssueFilters(ViolationFilters deprecatedFilters, DeprecatedViolations deprecatedViolations, org.sonar.api.issue.IssueFilter[] exclusionFilters) { this(deprecatedFilters, deprecatedViolations, exclusionFilters, new IssueFilter[0]); } diff --git a/sonar-plugin-api/src/main/java/org/sonar/api/issue/batch/IssueFilter.java b/sonar-plugin-api/src/main/java/org/sonar/api/issue/batch/IssueFilter.java index 1b4a765492b..ac20b11c6b3 100644 --- a/sonar-plugin-api/src/main/java/org/sonar/api/issue/batch/IssueFilter.java +++ b/sonar-plugin-api/src/main/java/org/sonar/api/issue/batch/IssueFilter.java @@ -19,6 +19,7 @@ */ package org.sonar.api.issue.batch; +import org.sonar.api.BatchExtension; import org.sonar.api.issue.Issue; /** @@ -26,7 +27,7 @@ import org.sonar.api.issue.Issue; * @since 4.0 * */ -public interface IssueFilter { +public interface IssueFilter extends BatchExtension { /** * The <code>accept</code> method is called for each {@link Issue} created during analysis, to check if it has to be persisted. Examples of use cases are: |