GCI105 StringConcatenation #Python #DLG #Build

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- [#78](https://github.com/green-code-initiative/creedengo-python/pull/78) Add rule GCI 105 on String Concatentation. This rule maybe apply to other rule
 - [#71](https://github.com/green-code-initiative/creedengo-python/pull/71) Add rule GCI96 Require Usecols Argument in Pandas Read Functions
 - [#72](https://github.com/green-code-initiative/creedengo-python/pull/72) Add rule GCI97 Optimize square computation (scalar vs vectorized method)
 

pom.xml

@@ -70,7 +70,7 @@
         <lombok.version>1.18.38</lombok.version>
 
         <!-- temporary version waiting for a real automatic release in creedengo repository -->
-        <creedengo-rules-specifications.version>2.3.0</creedengo-rules-specifications.version>
+        <creedengo-rules-specifications.version>2.4.0</creedengo-rules-specifications.version>
 
         <!-- URL of the Maven repository where sonarqube will be downloaded -->
         <test-it.orchestrator.artifactory.url>https://repo1.maven.org/maven2</test-it.orchestrator.artifactory.url>

src/it/java/org/greencodeinitiative/creedengo/python/integration/tests/GCIRulesIT.java

@@ -287,6 +287,8 @@ void testGCI96() {
 
         checkIssuesForFile(filePath, ruleId, ruleMsg, startLines, endLines, SEVERITY, TYPE, EFFORT_10MIN);
     }
+
+    @Test
     void testGCI97(){
         String filePath = "src/optimizeSquareComputation.py";
         String ruleId = "creedengo-python:GCI97";
@@ -300,5 +302,21 @@ void testGCI97(){
 
         checkIssuesForFile(filePath, ruleId, ruleMsg, startLines, endLines, SEVERITY, TYPE, EFFORT_1MIN);
     }
+    @Test
+    void testGCI105() {
+
+        String filePath = "src/stringConcatenation.py";
+        String ruleId = "creedengo-python:GCI105";
+        String ruleMsg = "Concatenation of strings should be done using f-strings or str.join()";
+        int[] startLines = new int[]{
+            5, 8, 10, 32, 38
+        };
+        int[] endLines = new int[]{
+            5, 8, 10, 32, 38
+        };
+
+        checkIssuesForFile(filePath, ruleId, ruleMsg, startLines, endLines, SEVERITY, TYPE, EFFORT_1MIN);
+
+    }
 
 }

src/it/test-projects/creedengo-python-plugin-test-project/src/stringConcatenation.py

@@ -0,0 +1,38 @@
+text = "hello"
+following_words = ["world", "I", "am", "a", "string", "concatenation"]
+
+for word in following_words:
+    text += word  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}
+
+text = "init"
+text += " add this"  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}
+
+text += [word for word in following_words]  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}
+
+
+result = " ".join([text] + following_words) 
+
+
+final = f"{text} {' '.join(following_words)}" 
+
+
+def build_string(base, parts):
+    return f"{base} {' '.join(parts)}"  
+
+mylist = []
+mylist += [1, 2, 3]  # Compliant
+
+
+count = 0
+count += 1  # Compliant
+
+
+msg = "start"
+if True:
+    msg += " continued"  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}
+
+
+def get_text():
+    return "function text"
+
+text += get_text()  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}

src/main/java/org/greencodeinitiative/creedengo/python/PythonRuleRepository.java

@@ -42,7 +42,8 @@ public class PythonRuleRepository implements RulesDefinition, PythonCustomRuleRe
             DetectUnoptimizedImageFormat.class,
             AvoidMultipleIfElseStatementCheck.class,
             PandasRequireUsecolsArgument.class,
-            OptimizeSquareComputation.class
+            OptimizeSquareComputation.class,
+            StringConcatenation.class
     );
 
     public static final String LANGUAGE = "py";

src/main/java/org/greencodeinitiative/creedengo/python/checks/StringConcatenation.java

@@ -0,0 +1,91 @@
+/*
+ * creedengo - Python language - Provides rules to reduce the environmental footprint of your Python programs
+ * Copyright © 2024 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.python.checks;
+
+
+import org.sonar.check.Rule;
+import org.sonar.plugins.python.api.PythonSubscriptionCheck;
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.CompoundAssignmentStatement;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.AssignmentStatement;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+
+@Rule(key="GCI105")
+public class StringConcatenation extends PythonSubscriptionCheck {
+
+    private final List<String> stringVariables = new ArrayList<>();
+
+  public static final String DESCRIPTION = "Concatenation of strings should be done using f-strings or str.join()";
+
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.STRING_ELEMENT, this::findStringVariable);
+
+    context.registerSyntaxNodeConsumer(Tree.Kind.COMPOUND_ASSIGNMENT, this::checkAssignment);
+
+  }
+
+  private void findStringVariable(SubscriptionContext context) {
+    Tree node = context.syntaxNode();
+    if (node.is(Tree.Kind.STRING_ELEMENT)) {
+        Tree current = node;
+        while (current != null && !current.is(Tree.Kind.ASSIGNMENT_STMT)) {
+            current = current.parent();
+        }
+
+        if (current != null && current.is(Tree.Kind.ASSIGNMENT_STMT)) {
+            AssignmentStatement assignment = (AssignmentStatement) current;
+
+
+            if (!assignment.assignedValue().is(Tree.Kind.LIST_LITERAL) && 
+                !assignment.assignedValue().is(Tree.Kind.LIST_COMPREHENSION)) {
+
+                String variableName = Utils.getVariableName(context);
+                if (variableName != null) {
+                    stringVariables.add(variableName);
+                }
+            }
+        }
+    }
+}
+
+  private void checkAssignment(SubscriptionContext context) {
+
+    CompoundAssignmentStatement compoundAssignment = (CompoundAssignmentStatement) context.syntaxNode();
+    if (compoundAssignment.compoundAssignmentToken().value().equals("+=")) {
+      Expression lhsExpression = compoundAssignment.lhsExpression();
+      if (lhsExpression.is(Tree.Kind.NAME)) {
+          String variableName = ((Name) lhsExpression).name();
+          if (stringVariables.contains(variableName)) {
+              context.addIssue(lhsExpression.firstToken(), DESCRIPTION);
+      }
+  }}}
+
+
+
+
+
+}

src/main/java/org/greencodeinitiative/creedengo/python/checks/Utils.java

@@ -0,0 +1,102 @@
+/*
+ * creedengo - Python language - Provides rules to reduce the environmental footprint of your Python programs
+ * Copyright © 2024 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.python.checks;
+
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.symbols.Symbol;
+import org.sonar.plugins.python.api.tree.Argument;
+import org.sonar.plugins.python.api.tree.AssignmentStatement;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.RegularArgument;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.Expression;
+
+import javax.annotation.CheckForNull;
+import java.util.List;
+import java.util.Objects;
+
+public class Utils {
+
+  private static boolean hasKeyword(Argument argument, String keyword) {
+    if (!argument.is(new Tree.Kind[] {Tree.Kind.REGULAR_ARGUMENT})) {
+      return false;
+    } else {
+      Name keywordArgument = ((RegularArgument) argument).keywordArgument();
+      return keywordArgument != null && keywordArgument.name().equals(keyword);
+    }
+  }
+
+  @CheckForNull
+  public static RegularArgument nthArgumentOrKeyword(int argPosition, String keyword, List<Argument> arguments) {
+    for (int i = 0; i < arguments.size(); ++i) {
+      Argument argument = (Argument) arguments.get(i);
+      if (hasKeyword(argument, keyword)) {
+        return (RegularArgument) argument;
+      }
+
+      if (argument.is(new Tree.Kind[] {Tree.Kind.REGULAR_ARGUMENT})) {
+        RegularArgument regularArgument = (RegularArgument) argument;
+        if (regularArgument.keywordArgument() == null && argPosition == i) {
+          return regularArgument;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  public static String getQualifiedName(CallExpression callExpression) {
+    Symbol symbol = callExpression.calleeSymbol();
+
+    return symbol != null && symbol.fullyQualifiedName() != null ? symbol.fullyQualifiedName() : "";
+  }
+
+  public static String getMethodName(CallExpression callExpression) {
+    Symbol symbol = callExpression.calleeSymbol();
+    return symbol != null && symbol.name() != null ? symbol.name() : "";
+  }
+
+  public static List<Argument> getArgumentsFromCall(CallExpression callExpression) {
+    try {
+      return Objects.requireNonNull(callExpression.argumentList()).arguments();
+    } catch (NullPointerException e) {
+      return List.of();
+    }
+  }
+
+  public static String getVariableName(SubscriptionContext context) {
+    Tree node = context.syntaxNode();
+    Tree current = node;
+    while (current != null && !current.is(Tree.Kind.ASSIGNMENT_STMT)) {
+        current = current.parent();
+    }
+    if (current != null && current.is(Tree.Kind.ASSIGNMENT_STMT)) {
+      AssignmentStatement assignment = (AssignmentStatement) current;
+      if (!assignment.lhsExpressions().isEmpty() && !assignment.lhsExpressions().get(0).expressions().isEmpty()) {
+              Expression leftExpr = assignment.lhsExpressions().get(0).expressions().get(0);
+              if (leftExpr.is(Tree.Kind.NAME)) {
+                  Name variableName = (Name) leftExpr;
+                  return variableName.name();
+              }
+          }
+
+    }
+    return null;
+  }
+}

src/main/resources/org/greencodeinitiative/creedengo/python/creedengo_way_profile.json

@@ -12,6 +12,7 @@
 		"GCI89",
 		"GCI96",
 		"GCI97",
+		"GCI105",
 		"GCI203",
 		"GCI404"
 	]

src/test/java/org/greencodeinitiative/creedengo/python/checks/StringConcatenationTest.java

@@ -0,0 +1,29 @@
+/*
+ * creedengo - Python language - Provides rules to reduce the environmental footprint of your Python programs
+ * Copyright © 2024 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.python.checks;
+
+import org.junit.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+public class StringConcatenationTest {
+
+  @Test
+  public void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/stringConcatenation.py", new StringConcatenation());
+  }
+}

src/test/resources/checks/stringConcatenation.py

@@ -0,0 +1,38 @@
+text = "hello"
+following_words = ["world", "I", "am", "a", "string", "concatenation"]
+
+for word in following_words:
+    text += word  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}
+
+text = "init"
+text += " add this"  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}
+
+text += [word for word in following_words]  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}
+
+
+result = " ".join([text] + following_words) 
+
+
+final = f"{text} {' '.join(following_words)}" 
+
+
+def build_string(base, parts):
+    return f"{base} {' '.join(parts)}"  
+
+mylist = []
+mylist += [1, 2, 3]  # Compliant
+
+
+count = 0
+count += 1  # Compliant
+
+
+msg = "start"
+if True:
+    msg += " continued"  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}
+
+
+def get_text():
+    return "function text"
+
+text += get_text()  # Noncompliant {{Concatenation of strings should be done using f-strings or str.join()}}