JS-1447 Generate built-in profiles from rspec metadata (#6583)

Author: vdiez

pom.xml

@@ -321,6 +321,7 @@
                 <exclude>**/*.d.ts</exclude>
                 <!-- Folders -->
                 <exclude>its/**/*</exclude>
+                <exclude>tsgolint/**/*</exclude>
                 <!-- Generated -->
                 <exclude>**/bin/**/*</exclude>
                 <exclude>**/dist/**/*</exclude>

sonar-plugin/css/src/main/resources/org/sonar/l10n/css/rules/rules.json

@@ -16,12 +16,18 @@
  */
 package org.sonar.plugins.javascript;
 
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumMap;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -45,15 +51,12 @@ public class JavaScriptProfilesDefinition implements BuiltInQualityProfilesDefin
 
   public static final String RESOURCE_PATH = "org/sonar/l10n/javascript/rules/javascript";
   public static final String SONAR_WAY_JSON = RESOURCE_PATH + "/Sonar_way_profile.json";
+  public static final String PROFILES_JSON = RESOURCE_PATH + "/profiles.json";
 
-  private static final Map<String, String> PROFILES = new HashMap<>();
+  private static final List<ProfileDefinition> PROFILES = loadProfiles();
   static final String SONAR_JASMIN_RULES_CLASS_NAME = "com.sonar.plugins.jasmin.api.JsRules";
   public static final String SECURITY_RULE_KEYS_METHOD_NAME = "getSecurityRuleKeys";
 
-  static {
-    PROFILES.put(SONAR_WAY, SONAR_WAY_JSON);
-  }
-
   private static final Map<Language, String> REPO_BY_LANGUAGE = new EnumMap<>(Language.class);
 
   static {
@@ -84,15 +87,24 @@ public JavaScriptProfilesDefinition(ProfileRegistrar[] profileRegistrars) {
 
   @Override
   public void define(Context context) {
-    createSonarWayProfile(JavaScriptLanguage.KEY, context);
-    createSonarWayProfile(TypeScriptLanguage.KEY, context);
+    createProfiles(JavaScriptLanguage.KEY, context);
+    createProfiles(TypeScriptLanguage.KEY, context);
   }
 
-  private void createSonarWayProfile(String language, Context context) {
-    NewBuiltInQualityProfile newProfile = context.createBuiltInQualityProfile(SONAR_WAY, language);
-    activateBuiltInRules(newProfile);
-    activateAdditionalRules(newProfile);
-    activateSecurityRules(newProfile, language);
+  private void createProfiles(String language, Context context) {
+    PROFILES.forEach(profile -> createProfile(profile, language, context));
+  }
+
+  private void createProfile(ProfileDefinition profile, String language, Context context) {
+    NewBuiltInQualityProfile newProfile = context.createBuiltInQualityProfile(
+      profile.name(),
+      language
+    );
+    activateBuiltInRules(newProfile, profile.path());
+    if (SONAR_WAY.equals(profile.name())) {
+      activateAdditionalRules(newProfile);
+      activateSecurityRules(newProfile, language);
+    }
     newProfile.done();
   }
 
@@ -101,19 +113,57 @@ private void createSonarWayProfile(String language, Context context) {
    *
    * @param profile profile to activate the rules for
    */
-  private static void activateBuiltInRules(NewBuiltInQualityProfile profile) {
+  private static void activateBuiltInRules(
+    NewBuiltInQualityProfile profile,
+    String jsonProfilePath
+  ) {
     var language = Language.of(profile.language());
     String repositoryKey = REPO_BY_LANGUAGE.get(language);
-    var jsonProfilePath = PROFILES.get(profile.name());
+    Set<String> activeKeys = BuiltInQualityProfileJsonLoader.loadActiveKeysFromJsonProfile(
+      jsonProfilePath
+    );
 
-    Set<String> activeKeysForBothLanguages =
-      BuiltInQualityProfileJsonLoader.loadActiveKeysFromJsonProfile(jsonProfilePath);
     ruleKeys(CheckList.getChecksForLanguage(language))
       .stream()
-      .filter(activeKeysForBothLanguages::contains)
+      .filter(activeKeys::contains)
       .forEach(key -> profile.activateRule(repositoryKey, key));
   }
 
+  private static List<ProfileDefinition> loadProfiles() {
+    try (
+      InputStream inputStream =
+        JavaScriptProfilesDefinition.class.getClassLoader().getResourceAsStream(PROFILES_JSON)
+    ) {
+      if (inputStream == null) {
+        throw new IllegalStateException("Missing built-in quality profile index: " + PROFILES_JSON);
+      }
+      JsonArray profiles = JsonParser.parseReader(
+        new InputStreamReader(inputStream, StandardCharsets.UTF_8)
+      ).getAsJsonArray();
+      List<ProfileDefinition> definitions = new ArrayList<>();
+      profiles.forEach(profile -> {
+        JsonObject profileJson = profile.getAsJsonObject();
+        String name = profileJson.get("name").getAsString();
+        String fileName = profileJson.get("fileName").getAsString();
+        definitions.add(new ProfileDefinition(name, RESOURCE_PATH + "/" + fileName));
+      });
+      if (
+        definitions
+          .stream()
+          .noneMatch(
+            profile -> SONAR_WAY.equals(profile.name()) && SONAR_WAY_JSON.equals(profile.path())
+          )
+      ) {
+        throw new IllegalStateException(
+          "Missing required built-in quality profile in " + PROFILES_JSON + ": " + SONAR_WAY
+        );
+      }
+      return definitions;
+    } catch (IOException e) {
+      throw new IllegalStateException("Failed to load built-in quality profile index", e);
+    }
+  }
+
   /**
    * Activate additional rules that are provided by other plugins.
    *
@@ -175,4 +225,23 @@ private static Set<String> ruleKeys(List<Class<? extends EslintHook>> checks) {
   private static String securityRuleMessage(Exception e) {
     return "no security rules added to builtin profile: " + e.getMessage();
   }
+
+  private static class ProfileDefinition {
+
+    private final String name;
+    private final String path;
+
+    private ProfileDefinition(String name, String path) {
+      this.name = name;
+      this.path = path;
+    }
+
+    String name() {
+      return name;
+    }
+
+    String path() {
+      return path;
+    }
+  }
 }

sonar-plugin/sonar-javascript-plugin/src/main/java/org/sonar/plugins/javascript/JavaScriptProfilesDefinition.java

@@ -17,13 +17,18 @@
 package org.sonar.plugins.javascript;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.plugins.javascript.JavaScriptProfilesDefinition.PROFILES_JSON;
 import static org.sonar.plugins.javascript.JavaScriptProfilesDefinition.SECURITY_RULE_KEYS_METHOD_NAME;
 import static org.sonar.plugins.javascript.JavaScriptProfilesDefinition.SONAR_JASMIN_RULES_CLASS_NAME;
 import static org.sonar.plugins.javascript.JavaScriptProfilesDefinition.SONAR_WAY_JSON;
 import static org.sonar.plugins.javascript.JavaScriptProfilesDefinition.getSecurityRuleKeys;
 
+import com.google.gson.JsonParser;
 import com.sonar.plugins.jasmin.api.JsRules;
+import java.io.InputStreamReader;
 import java.lang.annotation.Annotation;
+import java.nio.charset.StandardCharsets;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -154,6 +159,23 @@ void no_legacy_Key_in_profile_json() {
     assertThat(sonarWayKeys).isSubsetOf(allKeys);
   }
 
+  @Test
+  void should_define_all_profiles_from_generated_index() {
+    var profilesIndex = getClass().getClassLoader().getResourceAsStream(PROFILES_JSON);
+    assertThat(profilesIndex).isNotNull();
+
+    Set<String> profileNames = new HashSet<>();
+    JsonParser.parseReader(new InputStreamReader(profilesIndex, StandardCharsets.UTF_8))
+      .getAsJsonArray()
+      .forEach(profile -> profileNames.add(profile.getAsJsonObject().get("name").getAsString()));
+
+    assertThat(profileNames).isNotEmpty();
+    profileNames.forEach(profileName -> {
+      assertThat(context.profile(JavaScriptLanguage.KEY, profileName)).isNotNull();
+      assertThat(context.profile(TypeScriptLanguage.KEY, profileName)).isNotNull();
+    });
+  }
+
   @Test
   void should_contains_security_rules_if_available() {
     // no security rule available