[Renew] custom rules support sonar 9.9

pom.xml

@@ -10,21 +10,20 @@
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <sonar.version>8.6.1.40680</sonar.version>
   </properties>
 
   <dependencies>
     <dependency>
       <groupId>org.sonarsource.sonarqube</groupId>
       <artifactId>sonar-plugin-api</artifactId>
-      <version>${sonar.version}</version>
+      <version>7.9</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
       <groupId>org.sonarsource.sonarqube-plugins.cxx</groupId>
       <artifactId>sonar-cxx-plugin</artifactId>
       <type>sonar-plugin</type>
-      <version>0.9.7-SNAPSHOT</version>
+      <version>2.1.1-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
@@ -60,8 +59,8 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.8.1</version>
         <configuration>
-          <source>1.7</source>
-          <target>1.7</target>
+          <source>10</source>
+          <target>10</target>
         </configuration>
       </plugin>
     </plugins>

src/main/java/org/sonar/cxx/MyCustomRulesDefinition.java

@@ -1,24 +1,73 @@
 package org.sonar.cxx;
 
-import org.sonar.cxx.checks.UsingNamespaceCheck;
-import org.sonar.plugins.cxx.api.CustomCxxRulesDefinition;
+import org.sonar.api.config.internal.MapSettings;
+import org.sonar.api.resources.Language;
+import org.sonar.api.scanner.ScannerSide;
+import org.sonar.api.server.rule.RulesDefinition;
+import org.sonar.cxx.checks.*;
+import org.sonar.cxx.squidbridge.annotations.AnnotationBasedRulesDefinition;
+import org.sonar.plugins.cxx.CustomCxxRulesDefinition;
+import org.sonar.plugins.cxx.CxxLanguage;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+@ScannerSide
 public class MyCustomRulesDefinition extends CustomCxxRulesDefinition {
+  private static final Language LANGUAGE = new CxxLanguage(new MapSettings().asConfig());
+
+  @Override
+  public Language getLanguage() {
+    return LANGUAGE;
+  }
 
   @Override
   public String repositoryName() {
-    return "Repository";
+    return "Custom Repository";
   }
 
   @Override
   public String repositoryKey() {
-    return "repo";
+    return "customrepo";
   }
 
   @SuppressWarnings("rawtypes")
   @Override
   public Class[] checkClasses() {
     return new Class[] { UsingNamespaceCheck.class };
   }
+  @Override
+  public void define(RulesDefinition.Context context) {
+    var repo = context.createRepository(repositoryKey(), getLanguage().getKey())
+            .setName(repositoryName());
 
+    // Load metadata from check classes' annotations
+    new AnnotationBasedRulesDefinition(repo, getLanguage().getKey()).addRuleClasses(false,
+            Arrays.asList(checkClasses()));
+
+    // Optionally override html description from annotation with content from html files
+    repo.rules().forEach(rule -> rule.setHtmlDescription(loadResource("/org/sonar/l10n/cxx/rules/cxx/" + rule.key() + ".html")));
+    repo.done();
+  }
+
+  private String loadResource(String path) {
+    URL resource = getClass().getResource(path);
+    if (resource == null) {
+      throw new IllegalStateException("Resource not found: " + path);
+    }
+    ByteArrayOutputStream result = new ByteArrayOutputStream();
+    try (InputStream in = resource.openStream()) {
+      byte[] buffer = new byte[1024];
+      for (int len = in.read(buffer); len != -1; len = in.read(buffer)) {
+        result.write(buffer, 0, len);
+      }
+      return new String(result.toByteArray(), StandardCharsets.UTF_8);
+    } catch (IOException e) {
+      throw new IllegalStateException("Failed to read resource: " + path, e);
+    }
+  }
 }

src/main/java/org/sonar/cxx/MyCustomRulesPlugin.java

@@ -1,16 +1,13 @@
 package org.sonar.cxx;
+import org.sonar.api.Plugin;
 
-import java.util.List;
+public class MyCustomRulesPlugin implements Plugin {
 
-import org.sonar.api.SonarPlugin;
-
-import com.google.common.collect.ImmutableList;
-
-public class MyCustomRulesPlugin extends SonarPlugin {
-
-  @SuppressWarnings("rawtypes")
   @Override
-  public List getExtensions() {
-    return ImmutableList.of(MyCustomRulesDefinition.class);
+  public void define(Context context) {
+    context.addExtension(
+            MyCustomRulesDefinition.class
+    );
   }
+
 }

src/main/java/org/sonar/cxx/checks/UsingNamespaceCheck.java

@@ -1,27 +1,23 @@
 package org.sonar.cxx.checks;
 
-import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.check.Priority;
 import org.sonar.check.Rule;
+import org.sonar.cxx.squidbridge.annotations.ActivatedByDefault;
+import org.sonar.cxx.squidbridge.annotations.SqaleConstantRemediation;
+import org.sonar.cxx.squidbridge.checks.SquidCheck;
+import com.sonar.cxx.sslr.api.AstNode;
+import com.sonar.cxx.sslr.api.Grammar;
 import org.sonar.cxx.parser.CxxGrammarImpl;
-import org.sonar.squidbridge.annotations.ActivatedByDefault;
-import org.sonar.squidbridge.annotations.SqaleConstantRemediation;
-import org.sonar.squidbridge.annotations.SqaleSubCharacteristic;
-import org.sonar.squidbridge.checks.SquidCheck;
-
-import com.sonar.sslr.api.AstNode;
-import com.sonar.sslr.api.Grammar;
 
 @Rule(
-    key = "UsingNamespace",
+    key = UsingNamespaceCheck.RULE_KEY,
     name = "Using namespace directives are not allowed",
     priority = Priority.BLOCKER,
     description = "Using namespace directives are not allowed.")
 @ActivatedByDefault
-@SqaleSubCharacteristic(RulesDefinition.SubCharacteristics.ARCHITECTURE_RELIABILITY)
 @SqaleConstantRemediation("5min")
 public class UsingNamespaceCheck extends SquidCheck<Grammar> {
-
+  public static final String RULE_KEY = "UsingNamespace";
   @Override
   public void init() {
     subscribeTo(CxxGrammarImpl.usingDirective);

src/main/resources/org/sonar/l10n/cxx/rules/cxx/UsingNamespace.html

@@ -0,0 +1,21 @@
+<p>
+Sharing some naming conventions is a key point to make it possible for a team to efficiently collaborate. 
+This rule allows to check that all class names match a provided regular expression.
+</p>
+
+<h2>Non-compliant Code Example</h2>
+<p>To Do</p>
+
+<pre>
+class myClass {
+	...
+}
+</pre>
+
+<h2>Compliant Solution</h2>
+
+<pre>
+class MyClass {
+	...
+}
+</pre>

src/test/java/org/sonar/cxx/MyCustomRulesDefinitionTest.java

@@ -10,8 +10,8 @@ public class MyCustomRulesDefinitionTest {
   @Test
   public void test() {
     MyCustomRulesDefinition definition = new MyCustomRulesDefinition();
-    assertThat(definition.repositoryName()).isEqualTo("Repository");
-    assertThat(definition.repositoryKey()).isEqualTo("repo");
+    assertThat(definition.repositoryName()).isEqualTo("Custom Repository");
+    assertThat(definition.repositoryKey()).isEqualTo("customrepo");
     assertThat(definition.checkClasses().length).isEqualTo(1);
   }
 

src/test/java/org/sonar/cxx/MyCustomRulesPluginTest.java

@@ -3,14 +3,26 @@
 import static org.fest.assertions.Assertions.assertThat;
 
 import org.junit.Test;
-import org.sonar.cxx.MyCustomRulesPlugin;
+import org.sonar.api.Plugin;
+import org.sonar.api.SonarEdition;
+import org.sonar.api.SonarQubeSide;
+import org.sonar.api.SonarRuntime;
+import org.sonar.api.internal.SonarRuntimeImpl;
+import org.sonar.api.utils.Version;
 
 public class MyCustomRulesPluginTest {
 
   @Test
   public void test() {
+    SonarRuntime runtime = SonarRuntimeImpl.forSonarQube(
+            Version.create(8, 6),
+            SonarQubeSide.SCANNER,
+            SonarEdition.COMMUNITY
+    );
+    Plugin.Context context = new Plugin.Context(runtime);
     MyCustomRulesPlugin plugin = new MyCustomRulesPlugin();
-    assertThat(plugin.getExtensions().size()).isEqualTo(1);
+    plugin.define(context);
+    assertThat(context.getExtensions().size()).isEqualTo(1);
   }
 
 }

src/test/java/org/sonar/cxx/checks/CxxFileTester.java

@@ -24,5 +24,8 @@
 
 public class CxxFileTester {
   public InputFile cxxFile;
-  public SensorContextTester sensorContext;  
+  public SensorContextTester context;
+  public InputFile asInputFile() {
+    return cxxFile;
+  }
 }

src/test/java/org/sonar/cxx/checks/CxxFileTesterHelper.java

@@ -20,38 +20,60 @@
 package org.sonar.cxx.checks;
 
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
-import java.nio.file.Files;
+import java.nio.charset.Charset;
+import java.nio.file.Path;
+import org.apache.commons.io.ByteOrderMark;
+import org.apache.commons.io.input.BOMInputStream;
 import org.sonar.api.batch.fs.internal.DefaultInputFile;
+import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.sensor.internal.SensorContextTester;
 
-/**
- *
- * @author jocs
- */
-public class CxxFileTesterHelper {
-
-  public static CxxFileTester CreateCxxFileTester(String fileName, String basePath) throws UnsupportedEncodingException, IOException {
-    CxxFileTester tester = new CxxFileTester();
-    tester.sensorContext = SensorContextTester.create(new File(basePath));
+public final class CxxFileTesterHelper {
 
-    String content = new String(Files.readAllBytes(new File(tester.sensorContext.fileSystem().baseDir(), fileName).toPath()), "UTF-8");
-    tester.sensorContext.fileSystem().add(new DefaultInputFile("myProjectKey", fileName).initMetadata(content));
-    tester.cxxFile = tester.sensorContext.fileSystem().inputFile(tester.sensorContext.fileSystem().predicates().hasPath(fileName));
-
-    return tester;
+  private CxxFileTesterHelper() {
+    // utility class
   }
-
-  public static CxxFileTester CreateCxxFileTester(String fileName, String basePath, String encoding) throws UnsupportedEncodingException, IOException {
+
+  public static CxxFileTester create(String fileName, String basePath)
+          throws UnsupportedEncodingException, IOException {
+    return create(fileName, basePath, Charset.defaultCharset());
+  }
+
+  public static CxxFileTester create(String fileName, String basePath, Charset charset)
+          throws UnsupportedEncodingException, IOException {
     CxxFileTester tester = new CxxFileTester();
-    tester.sensorContext = SensorContextTester.create(new File(basePath));
 
-    String content = new String(Files.readAllBytes(new File(tester.sensorContext.fileSystem().baseDir(), fileName).toPath()), encoding);
-    tester.sensorContext.fileSystem().add(new DefaultInputFile("myProjectKey", fileName).initMetadata(content));
-    tester.cxxFile = tester.sensorContext.fileSystem().inputFile(tester.sensorContext.fileSystem().predicates().hasPath(fileName));
-    
+    tester.context = SensorContextTester.create(new File(basePath));
+    tester.cxxFile = createInputFile(fileName, basePath, charset);
+    tester.context.fileSystem().add(tester.cxxFile);
+
     return tester;
   }
-
+
+  private static DefaultInputFile createInputFile(String fileName, String basePath, Charset charset) throws IOException {
+    TestInputFileBuilder fb = TestInputFileBuilder.create("", fileName);
+
+    fb.setCharset(charset);
+    fb.setProjectBaseDir(Path.of(basePath));
+    fb.setContents(getSourceCode(Path.of(basePath, fileName).toFile(), charset));
+
+    return fb.build();
+  }
+
+  private static String getSourceCode(File filename, Charset defaultCharset) throws IOException {
+    try (BOMInputStream bomInputStream = new BOMInputStream(new FileInputStream(filename),
+            ByteOrderMark.UTF_8,
+            ByteOrderMark.UTF_16LE,
+            ByteOrderMark.UTF_16BE,
+            ByteOrderMark.UTF_32LE,
+            ByteOrderMark.UTF_32BE)) {
+      ByteOrderMark bom = bomInputStream.getBOM();
+      Charset charset = bom != null ? Charset.forName(bom.getCharsetName()) : defaultCharset;
+      byte[] bytes = bomInputStream.readAllBytes();
+      return new String(bytes, charset);
+    }
+  }
 }

src/test/java/org/sonar/cxx/checks/UsingNamespaceCheckTest.java

@@ -1,22 +1,24 @@
 package org.sonar.cxx.checks;
 
-import java.io.IOException;
-import java.io.UnsupportedEncodingException;
 import org.junit.Test;
+import org.sonar.cxx.checks.UsingNamespaceCheck;
 import org.sonar.cxx.CxxAstScanner;
-import org.sonar.squidbridge.api.SourceFile;
-import org.sonar.squidbridge.checks.CheckMessagesVerifier;
+import org.sonar.cxx.squidbridge.api.SourceFile;
+import org.sonar.cxx.squidbridge.checks.CheckMessagesVerifier;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
 
 public class UsingNamespaceCheckTest {
 
   @Test
   public void check() throws UnsupportedEncodingException, IOException {
-    UsingNamespaceCheck check = new UsingNamespaceCheck();
+    UsingNamespaceCheck usingNamespaceCheck = new UsingNamespaceCheck();
 
-    CxxFileTester tester = CxxFileTesterHelper.CreateCxxFileTester("src/test/resources/checks/UsingNamespaceCheck.cc", ".");
-    SourceFile file = CxxAstScanner.scanSingleFile(tester.cxxFile, tester.sensorContext, check);
+    CxxFileTester testerHelper = CxxFileTesterHelper.create("src/test/resources/checks/UsingNamespaceCheck.cc", ".");
+    SourceFile sourceFile = CxxAstScanner.scanSingleInputFile(testerHelper.asInputFile(), usingNamespaceCheck);
 
-    CheckMessagesVerifier.verify(file.getCheckMessages())
+    CheckMessagesVerifier.verify(sourceFile.getCheckMessages())
       .next().atLine(1).withMessage("Using namespace are not allowed.")
       .noMore();
   }