From bef2183dc7174bc37a3adf46a0d666264f3ba155 Mon Sep 17 00:00:00 2001
From: Juan Ignacio Barisich <juan.barisich@gmail.com>
Date: Fri, 19 Jul 2013 12:02:37 -0300
Subject: [PATCH 1/2] ConsecutiveAppendsShouldReuse rule

---
 .../xml/ConsecutiveAppendsShouldReuse.xml     | 187 ++++++++++++++++++
 1 file changed, 187 insertions(+)
 create mode 100644 pmd/src/test/resources/net/sourceforge/pmd/lang/java/rule/strings/xml/ConsecutiveAppendsShouldReuse.xml

diff --git a/pmd/src/test/resources/net/sourceforge/pmd/lang/java/rule/strings/xml/ConsecutiveAppendsShouldReuse.xml b/pmd/src/test/resources/net/sourceforge/pmd/lang/java/rule/strings/xml/ConsecutiveAppendsShouldReuse.xml
new file mode 100644
index 0000000000..55c8c8d93a
--- /dev/null
+++ b/pmd/src/test/resources/net/sourceforge/pmd/lang/java/rule/strings/xml/ConsecutiveAppendsShouldReuse.xml
@@ -0,0 +1,187 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<test-data>
+    <test-code>
+        <description><![CDATA[
+1, Single append, should be ok
+     ]]></description>
+        <expected-problems>0</expected-problems>
+        <code><![CDATA[
+public class Foo {
+   private static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(Foo.class);
+   public void bar() {
+       StringBuffer sb = new StringBuffer(15);
+       sb.append("foo");
+   }
+   
+   public void bar2() {
+       StringBuilder sb = new StringBuilder(15);
+       sb.append("foo");
+   }
+}
+     ]]></code>
+    </test-code>
+    <test-code>
+        <description><![CDATA[
+2, Consecutive appends with reuse, should be ok
+     ]]></description>
+        <expected-problems>0</expected-problems>
+        <code><![CDATA[
+public class Foo {
+   private static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(Foo.class);
+   public void bar() {
+       StringBuffer sb = new StringBuffer(15);
+       sb.append("Hello").append("World");
+   }
+   
+   public void bar2() {
+       StringBuilder sb = new StringBuilder(15);
+       sb.append("Hello").append("World");
+   }
+}
+     ]]></code>
+    </test-code>
+	<test-code>
+	    <description><![CDATA[
+3, Single append on different method, should be ok
+	     ]]></description>
+        <expected-problems>0</expected-problems>
+        <code><![CDATA[
+public class Foo {
+   private static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(Foo.class);
+   public void bar() {
+       StringBuffer sb = new StringBuffer(15);
+       sb.append("Hello");
+   }
+   
+   public void bar2() {
+       StringBuffer sb = new StringBuffer(15);
+       sb.append("Hello");
+   }
+   
+   public void bar3() {
+       StringBuilder sb = new StringBuilder(15);
+       sb.append("Hello");
+   }
+   
+   public void bar4() {
+       StringBuilder sb = new StringBuilder(15);
+       sb.append("Hello");
+   }
+}
+     ]]></code>
+    </test-code>			
+    <test-code>
+	        <description><![CDATA[
+4, Single append on different objects, should be ok
+	     ]]></description>
+        <expected-problems>0</expected-problems>
+        <code><![CDATA[
+public class Foo {
+   private static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(Foo.class);
+   public void bar() {
+       StringBuffer sb = new StringBuffer(15);
+       sb.append("Hello");
+       StringBuffer sb2 = new StringBuffer(15);
+       sb2.append("World");
+   }
+   
+   public void bar2() {
+       StringBuilder sb = new StringBuilder(15);
+       sb.append("Hello");
+       StringBuilder sb2 = new StringBuilder(15);
+       sb2.append("World");
+   }
+}
+     ]]></code>
+    </test-code>
+    <test-code>
+        <description><![CDATA[
+5, Consecutive literal appends without reuse, not ok
+     ]]></description>
+        <expected-problems>2</expected-problems>
+        <code><![CDATA[
+public class Foo {
+   private static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(Foo.class);
+   public void bar() {
+       StringBuffer sb = new StringBuffer(15);
+       sb.append("Hello");
+       sb.append("World");
+   }
+   
+   public void bar2() {
+       StringBuilder sb = new StringBuilder(15);
+       sb.append("Hello");
+       sb.append("World");
+   }
+}
+     ]]></code>
+    </test-code>   
+        <test-code>
+        <description><![CDATA[
+6, Consecutive variable appends without reuse, not ok
+     ]]></description>
+        <expected-problems>2</expected-problems>
+        <code><![CDATA[
+public class Foo {
+   private static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(Foo.class);
+   public void bar() {
+       StringBuffer sb = new StringBuffer(15);
+       String foo = "Hello";
+       String foo2 = "World";
+       sb.append(foo);
+       sb.append(foo2);
+   }
+   
+   public void bar2() {
+       StringBuilder sb = new StringBuilder(15);
+       String foo = "Hello";
+       String foo2 = "World";
+       sb.append(foo);
+       sb.append(foo2);
+   }
+}
+     ]]></code>
+    </test-code> 
+    <test-code>
+        <description><![CDATA[
+7, Consecutive appends in different blocks, should be ok
+     ]]></description>
+        <expected-problems>0</expected-problems>
+        <code><![CDATA[
+public class Foo {
+   private static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(Foo.class);
+   public void bar() {
+       StringBuffer sb = new StringBuffer(15);
+       sb.append("Hello");
+       while(true) {
+          sb.append("World");
+       }
+   }
+   
+   public void bar2() {
+       StringBuffer sb = new StringBuffer(15);
+       sb.append("Hello");
+       if(true) {
+          sb.append("World");
+       }
+   }
+   
+   public void bar3() {
+       StringBuilder sb = new StringBuilder(15);
+       sb.append("Hello");
+       while(true) {
+          sb.append("World");
+       }
+   }
+   
+   public void bar4() {
+       StringBuilder sb = new StringBuilder(15);
+       sb.append("Hello");
+       if(true) {
+          sb.append("World");
+       }
+   }
+}
+     ]]></code>
+    </test-code>
+</test-data>

From 3cb34969eb122a2c55a6580364ca1478300e7ab9 Mon Sep 17 00:00:00 2001
From: Juan Ignacio Barisich <juan.barisich@gmail.com>
Date: Fri, 19 Jul 2013 12:05:24 -0300
Subject: [PATCH 2/2] ConsecutiveAppendsShouldReuse rule

---
 .../main/resources/rulesets/java/strings.xml  | 52 +++++++++++++++++++
 .../java/rule/strings/StringsRulesTest.java   |  1 +
 2 files changed, 53 insertions(+)

diff --git a/pmd/src/main/resources/rulesets/java/strings.xml b/pmd/src/main/resources/rulesets/java/strings.xml
index 668e83518a..c5cbaba164 100644
--- a/pmd/src/main/resources/rulesets/java/strings.xml
+++ b/pmd/src/main/resources/rulesets/java/strings.xml
@@ -147,6 +147,58 @@ sb.append('a');		// use this instead
     </example>
     </rule>
 
+<rule name="ConsecutiveAppendsShouldReuse"
+        language="java"
+        since="5.1"
+        message="StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable."
+        class="net.sourceforge.pmd.lang.rule.XPathRule"
+        externalInfoUrl="${pmd.website.baseurl}/rules/java/strings.html#ConsecutiveAppendsShouldReuse">
+    <description>
+Consecutively calls to StringBuffer/StringBuilder .append must reuse the target object. This will improve the performance. 
+    </description>
+    <priority>3</priority>
+    <properties>
+        <property name="xpath">
+            <value>
+<![CDATA[
+//BlockStatement[./Statement/StatementExpression//PrimaryPrefix/Name[ends-with(@Image,'.append')]
+                                      [substring-before(@Image, '.') =
+                                         ancestor::Block//LocalVariableDeclaration[./Type//ClassOrInterfaceType[@Image='StringBuffer']]//VariableDeclaratorId/@Image
+                                      ]
+                ]/following-sibling::*[1][./Statement/StatementExpression//PrimaryPrefix/Name[ends-with(@Image,'.append')]
+                                         [substring-before(@Image, '.') = 
+                                             ancestor::Block//LocalVariableDeclaration[./Type//ClassOrInterfaceType[@Image='StringBuffer']]//VariableDeclaratorId/@Image
+                                         ]
+                                      ] 
+|
+//BlockStatement[./Statement/StatementExpression//PrimaryPrefix/Name[ends-with(@Image,'.append')]
+                                      [substring-before(@Image, '.') = 
+                                         ancestor::Block//LocalVariableDeclaration[./Type//ClassOrInterfaceType[@Image='StringBuilder']]//VariableDeclaratorId/@Image
+                                      ]
+                ]/following-sibling::*[1][./Statement/StatementExpression//PrimaryPrefix/Name[ends-with(@Image,'.append')]
+                                         [substring-before(@Image, '.') = 
+                                             ancestor::Block//LocalVariableDeclaration[./Type//ClassOrInterfaceType[@Image='StringBuilder']]//VariableDeclaratorId/@Image
+                                         ]
+                                      ]
+]]>
+            </value>
+        </property>
+    </properties>
+    <example>
+<![CDATA[
+String foo = " ";
+
+StringBuffer buf = new StringBuffer();
+buf.append("Hello"); // poor
+buf.append(foo);
+buf.append("World");
+
+StringBuffer buf = new StringBuffer();
+buf.append("Hello").append(foo).append("World"); // good
+]]>
+    </example>
+  </rule>
+
         <rule name="ConsecutiveLiteralAppends"
         since="3.5"
         message="StringBuffer (or StringBuilder).append is called {0} consecutive times with literal Strings. Use a single append with a single combined String."
diff --git a/pmd/src/test/java/net/sourceforge/pmd/lang/java/rule/strings/StringsRulesTest.java b/pmd/src/test/java/net/sourceforge/pmd/lang/java/rule/strings/StringsRulesTest.java
index aa53c1c0d8..a1acedfb5a 100644
--- a/pmd/src/test/java/net/sourceforge/pmd/lang/java/rule/strings/StringsRulesTest.java
+++ b/pmd/src/test/java/net/sourceforge/pmd/lang/java/rule/strings/StringsRulesTest.java
@@ -13,6 +13,7 @@ public class StringsRulesTest extends SimpleAggregatorTst {
     public void setUp() {
         addRule(RULESET, "AppendCharacterWithChar");
         addRule(RULESET, "AvoidStringBufferField");
+        addRule(RULESET, "ConsecutiveAppendsShouldReuse");
         addRule(RULESET, "ConsecutiveLiteralAppends");
         addRule(RULESET, "InefficientEmptyStringCheck");
         addRule(RULESET, "InefficientStringBuffering");