Sonar codemod for defining a constant instead of duplicating literal string n times (#262)

example
https://sonarcloud.io/project/issues?open=AYu2g5It97lOFaqEjR1c&id=pixee_codemodder-java

reference https://rules.sonarsource.com/java/RSPEC-1192/

This codemod is approached in two ways based on the reported case by
sonarcloud:

1. When sonar reports the message `Use already-defined constant
'MY_CONSTANT' instead of duplicating its value here` where we take the
constant name inside the single quotes from the issue message to just
replace it.

2. When sonar reports a message like `Define a constant instead of
duplicating this literal "password" 3 times` where we need to generate a
constant name, add it to the classas a field declarator and replace it
at the reported locations.

**TO GENERATE A CONSTANT NAME**
We will use the string value as the constant name but there are some
considerations:
* We will keep only alphanumeric characters
* We remove other characters that are not alphanumeric
* If value has no alphanumeric characters, we will take parent's node
name as its name, but if there's a case where we couldn't retrieve
parent's node name, `CONST` value will be taken as the constant name
* We will add a counter suffix to the variable name if there are any
collisions to other declared variables in the class
* Snake case is the default naming convention we are using, but before
applying it, we will look for other constants declared in class to check
the naming convention used, so if camel case is used, generated constant
will be camel cased

**New constant will be added as a `private` member of the class**

Author: carlosu7

core-codemods/src/main/java/io/codemodder/codemods/ConstantNameStringGenerator.java

@@ -0,0 +1,138 @@
+package io.codemodder.codemods;
+
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/** This class generates constant names based on given values and parent node name. */
+final class ConstantNameStringGenerator {
+
+  private ConstantNameStringGenerator() {}
+
+  /**
+   * Generates a unique constant name based on the provided string literal expression value,
+   * declared variables, and the name of the parent node (if available). If there's a collision, a
+   * suffix counter is added.
+   */
+  static String generateConstantName(
+      final String stringLiteralExprValue,
+      final Set<String> declaredVariables,
+      final String parentNodeName,
+      final boolean isSnakeCase) {
+    final String snakeCaseConstantName =
+        formatStringValueToConstantSnakeCaseNomenclature(stringLiteralExprValue, parentNodeName);
+
+    final String constantName =
+        isSnakeCase ? snakeCaseConstantName : convertSnakeCaseToCamelCase(snakeCaseConstantName);
+
+    StringBuilder constantNameBuilder = new StringBuilder(constantName);
+    int counter = 0;
+
+    while (existsVariable(constantNameBuilder.toString(), declaredVariables)) {
+      // If the constant name already exists, append a counter to make it unique
+      constantNameBuilder = new StringBuilder(constantName);
+      if (counter != 0) {
+        if (isSnakeCase) {
+          constantNameBuilder.append("_");
+        }
+        constantNameBuilder.append(counter);
+      }
+      counter++;
+    }
+
+    return constantNameBuilder.toString();
+  }
+
+  /**
+   * This method takes a snake-cased string as input and transforms it into a camel-cased string. It
+   * splits the input string by underscores, capitalizes the first letter of each subsequent word,
+   * and concatenates the words to form the camel-cased result.
+   */
+  private static String convertSnakeCaseToCamelCase(String snakeCaseString) {
+    StringBuilder camelCaseBuilder = new StringBuilder();
+
+    // Split the snake case string by underscores
+    String[] words = snakeCaseString.split("_");
+
+    // Append the first word with lowercase
+    camelCaseBuilder.append(words[0].toLowerCase());
+
+    // Capitalize the first letter of each subsequent word and append
+    for (int i = 1; i < words.length; i++) {
+      String capitalizedWord =
+          words[i].substring(0, 1).toUpperCase() + words[i].substring(1).toLowerCase();
+      camelCaseBuilder.append(capitalizedWord);
+    }
+
+    return camelCaseBuilder.toString();
+  }
+
+  /**
+   * Formats the value to be used in the constant name. The process involves removing leading
+   * numeric characters, special characters, and spaces from the name, and converting it to
+   * uppercase to comply with Java constant naming conventions.
+   */
+  private static String formatStringValueToConstantSnakeCaseNomenclature(
+      final String stringLiteralExprValue, final String parentNodeName) {
+
+    final String constName = buildName(stringLiteralExprValue, parentNodeName);
+
+    final String sanitizedString = sanitizeStringToOnlyAlphaNumericAndUnderscore(constName);
+
+    final String stringWithoutLeadingNumericCharacters =
+        sanitizedString.replaceAll("^\\d*(_)*", "");
+
+    return stringWithoutLeadingNumericCharacters.toUpperCase();
+  }
+
+  /**
+   * Builds the name to be used in the constant name. It checks if the provided string literal
+   * expression value contains only non-alphabetical characters. If it doesn't, the original value
+   * is returned as is. Otherwise, the method combines the provided string literal expression value
+   * with an optional prefix based on the parent node name (if available) to create a base name.
+   */
+  private static String buildName(
+      final String stringLiteralExprValue, final String parentNodeName) {
+
+    if (!containsOnlyNonAlpha(stringLiteralExprValue)) {
+      return stringLiteralExprValue;
+    }
+
+    return parentNodeName != null ? parentNodeName : "CONST";
+  }
+
+  /** Checks if the input contains only non-alpha characters. */
+  private static boolean containsOnlyNonAlpha(final String input) {
+    // Use a regular expression to check if the string contains only non-alpha characters
+    return input.matches("[^a-zA-Z]+");
+  }
+
+  /** Sanitizes the input string by keeping only alphanumeric characters and underscores. */
+  private static String sanitizeStringToOnlyAlphaNumericAndUnderscore(final String input) {
+    // Use a regular expression to keep only alphanumeric characters and underscores
+    final Pattern pattern = Pattern.compile("\\W");
+    final Matcher matcher = pattern.matcher(input);
+
+    // Replace non-alphanumeric characters with a single space
+    final String stringWithSpaces = matcher.replaceAll(" ");
+
+    // Replace consecutive spaces with a single space
+    final String stringWithSingleSpaces = stringWithSpaces.replaceAll("\\s+", " ");
+
+    // Replace spaces with underscores
+    return stringWithSingleSpaces.trim().replace(" ", "_");
+  }
+
+  /**
+   * Checks if a variable with the given constant name already exists in the declared variables set.
+   */
+  private static boolean existsVariable(
+      final String constantName, final Set<String> declaredVariables) {
+
+    if (declaredVariables == null || declaredVariables.isEmpty()) {
+      return false;
+    }
+
+    return declaredVariables.contains(constantName);
+  }
+}

core-codemods/src/main/java/io/codemodder/codemods/CreateConstantForLiteral.java

@@ -0,0 +1,165 @@
+package io.codemodder.codemods;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.Modifier;
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.BodyDeclaration;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.expr.StringLiteralExpr;
+import com.github.javaparser.ast.nodeTypes.NodeWithSimpleName;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.ast.type.Type;
+import io.codemodder.CodemodInvocationContext;
+import io.codemodder.providers.sonar.api.Issue;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * A class that extends DefineConstantForLiteral and specializes in creating new constants for
+ * string literals in Java code.
+ */
+final class CreateConstantForLiteral extends DefineConstantForLiteral {
+
+  CreateConstantForLiteral(
+      final CodemodInvocationContext context,
+      final CompilationUnit cu,
+      final StringLiteralExpr stringLiteralExpr,
+      final Issue issue) {
+    super(context, cu, stringLiteralExpr, issue);
+  }
+
+  /**
+   * Retrieves the suggested constant name from the issue's message. The method utilizes a {@link
+   * ConstantNameStringGenerator} to generate a unique constant name based on various factors such
+   * as the string literal value, existing names in the CompilationUnit, parent node name, and
+   * naming conventions.
+   */
+  @Override
+  protected String getConstantName() {
+    final List<FieldDeclaration> constantFieldDeclarations =
+        findDeclaredConstantsInClassOrInterface();
+
+    final NodeWithSimpleName<?> nodeWithSimpleName = findAncestorWithSimpleName(stringLiteralExpr);
+
+    final String parentNodeName =
+        nodeWithSimpleName != null ? nodeWithSimpleName.getNameAsString() : null;
+
+    return ConstantNameStringGenerator.generateConstantName(
+        stringLiteralExpr.getValue(),
+        getNamesInCu(),
+        parentNodeName,
+        isUsingSnakeCase(constantFieldDeclarations));
+  }
+
+  /** Retrieves the names of all nodes with simple names in the CompilationUnit. */
+  private Set<String> getNamesInCu() {
+    return cu.findAll(Node.class).stream()
+        .filter(node -> node instanceof NodeWithSimpleName<?>)
+        .map(node -> (NodeWithSimpleName<?>) node)
+        .map(NodeWithSimpleName::getNameAsString)
+        .collect(Collectors.toSet());
+  }
+
+  /** Defines a new constant by adding a {@link FieldDeclaration} to the class or interface. */
+  @Override
+  protected void defineConstant(final String constantName) {
+    addConstantFieldToClass(createConstantField(constantName));
+  }
+
+  /**
+   * Adds a {@link FieldDeclaration} as the first member of the provided {@link
+   * ClassOrInterfaceDeclaration}
+   */
+  protected void addConstantFieldToClass(final FieldDeclaration constantField) {
+
+    final NodeList<BodyDeclaration<?>> members = classOrInterfaceDeclaration.getMembers();
+
+    members.addFirst(constantField);
+  }
+
+  /** Creates a {@link FieldDeclaration} of {@link String} type with the constant name provided */
+  private FieldDeclaration createConstantField(final String constantName) {
+
+    final NodeList<Modifier> modifiers =
+        NodeList.nodeList(
+            Modifier.privateModifier(), Modifier.staticModifier(), Modifier.finalModifier());
+
+    final Type type = new ClassOrInterfaceType(null, "String");
+
+    final VariableDeclarator variableDeclarator =
+        new VariableDeclarator(
+            type, constantName, new StringLiteralExpr(stringLiteralExpr.getValue()));
+
+    return new FieldDeclaration(modifiers, variableDeclarator);
+  }
+
+  /**
+   * Retrieves the first ancestor node that is a {@link NodeWithSimpleName} of a {@link
+   * StringLiteralExpr}
+   */
+  private NodeWithSimpleName<?> findAncestorWithSimpleName(
+      final StringLiteralExpr stringLiteralExpr) {
+    Optional<Node> parentNodeOptional = stringLiteralExpr.getParentNode();
+
+    while (parentNodeOptional.isPresent()
+        && !(parentNodeOptional.get() instanceof NodeWithSimpleName)) {
+      parentNodeOptional = parentNodeOptional.get().getParentNode();
+    }
+
+    return (NodeWithSimpleName<?>) parentNodeOptional.orElse(null);
+  }
+
+  /**
+   * This method takes a {@link ClassOrInterfaceDeclaration} as input, filters its members to
+   * include only {@link FieldDeclaration} nodes, and further filters these FieldDeclarations to
+   * select those that are declared as static, final, and have a type of String. The resulting list
+   * represents the declared constants in the given class or interface.
+   */
+  private List<FieldDeclaration> findDeclaredConstantsInClassOrInterface() {
+    return classOrInterfaceDeclaration.getMembers().stream()
+        .filter(FieldDeclaration.class::isInstance)
+        .map(FieldDeclaration.class::cast)
+        .filter(
+            fieldDeclaration ->
+                fieldDeclaration.getModifiers().contains(Modifier.staticModifier())
+                    && fieldDeclaration.getModifiers().contains(Modifier.finalModifier())
+                    && containsStringType(fieldDeclaration))
+        .toList();
+  }
+
+  /**
+   * This method takes a list of {@link FieldDeclaration} objects representing constant fields. It
+   * checks if the first constant field's name contains an underscore or is entirely in uppercase,
+   * indicating the use of snake case naming convention. If the list is empty, the method returns
+   * true as there are no constant fields to assess.
+   */
+  private boolean isUsingSnakeCase(final List<FieldDeclaration> constantFieldDeclarations) {
+    if (constantFieldDeclarations == null || constantFieldDeclarations.isEmpty()) {
+      return true;
+    }
+
+    final String constantName = constantFieldDeclarations.get(0).getVariable(0).getNameAsString();
+
+    return constantName.contains("_") || constantName.equals(constantName.toUpperCase());
+  }
+
+  /**
+   * Checks if the first constant field's name contains an underscore or is entirely in uppercase,
+   * indicating the use of snake case naming convention.
+   */
+  private boolean containsStringType(final FieldDeclaration fieldDeclaration) {
+    for (VariableDeclarator variable : fieldDeclaration.getVariables()) {
+      final Type fieldType = variable.getType();
+      if (fieldType instanceof ClassOrInterfaceType classOrInterfaceType
+          && classOrInterfaceType.getNameAsString().equals("String")) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

core-codemods/src/main/java/io/codemodder/codemods/DefaultCodemods.java

@@ -17,6 +17,7 @@ public static List<Class<? extends CodeChanger>> asList() {
         AddMissingOverrideCodemod.class,
         AvoidImplicitPublicConstructorCodemod.class,
         DeclareVariableOnSeparateLineCodemod.class,
+        DefineConstantForLiteralCodemod.class,
         DisableAutomaticDirContextDeserializationCodemod.class,
         FixRedundantStaticOnEnumCodemod.class,
         HardenJavaDeserializationCodemod.class,