From 6e02494e5ec3c4b00d723ce652dd1e3255e4ffbd Mon Sep 17 00:00:00 2001
From: Andreas Dangel <adangel@users.sourceforge.net>
Date: Mon, 14 Aug 2017 16:37:44 +0200
Subject: [PATCH] [doc] [java] Adjust externalInfoUrl properties to new site -
 Part 1

Note: I also took the chance to fix tab damage
---
 .../main/resources/rulesets/java/android.xml  |  39 ++-
 .../main/resources/rulesets/java/basic.xml    | 328 +++++++++---------
 .../main/resources/rulesets/java/braces.xml   |  31 +-
 .../main/resources/rulesets/java/clone.xml    |  53 ++-
 .../main/resources/rulesets/java/codesize.xml | 243 +++++++------
 .../main/resources/rulesets/java/comments.xml |  38 +-
 .../resources/rulesets/java/controversial.xml | 249 ++++++-------
 .../main/resources/rulesets/java/coupling.xml |  97 +++---
 .../pmd/AbstractRuleSetFactoryTest.java       |   9 +-
 pom.xml                                       |   4 +-
 10 files changed, 531 insertions(+), 560 deletions(-)

diff --git a/pmd-java/src/main/resources/rulesets/java/android.xml b/pmd-java/src/main/resources/rulesets/java/android.xml
index ff8daf3c9b..5988065afc 100644
--- a/pmd-java/src/main/resources/rulesets/java/android.xml
+++ b/pmd-java/src/main/resources/rulesets/java/android.xml
@@ -10,10 +10,11 @@ To get better results, make sure that the auxclasspath is defined for type resol
   </description>
 
   <rule name="CallSuperFirst"
-      since="4.2.5" language="java"
+      since="4.2.5"
+      language="java"
       message="super should be called at the start of the method"
       class="net.sourceforge.pmd.lang.rule.XPathRule"
-      externalInfoUrl="${pmd.website.baseurl}/rules/java/android.html#CallSuperFirst">
+      externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_android.html#callsuperfirst">
     <description>Super should be called at the start of the method</description>
     <priority>3</priority>
     <properties>
@@ -42,20 +43,21 @@ To get better results, make sure that the auxclasspath is defined for type resol
     </properties>
     <example><![CDATA[
 public class DummyActivity extends Activity {
-	public void onCreate(Bundle bundle) {
-     // missing call to super.onCreate(bundle)
-		foo();
-	}
+    public void onCreate(Bundle bundle) {
+        // missing call to super.onCreate(bundle)
+        foo();
+    }
 }
 ]]>
     </example>
   </rule>
 
   <rule name="CallSuperLast"
-      since="4.2.5" language="java"
+      since="4.2.5"
+      language="java"
       message="super should be called at the end of the method"
       class="net.sourceforge.pmd.lang.rule.XPathRule"
-      externalInfoUrl="${pmd.website.baseurl}/rules/java/android.html#CallSuperLast">
+      externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_android.html#callsuperlast">
     <description>Super should be called at the end of the method</description>
     <priority>3</priority>
     <properties>
@@ -84,20 +86,21 @@ public class DummyActivity extends Activity {
     <example>
       <![CDATA[
 public class DummyActivity extends Activity {
-	public void onPause() {
-		foo();
-		// missing call to super.onPause()
-	}
+    public void onPause() {
+        foo();
+        // missing call to super.onPause()
+    }
 }
 ]]>
     </example>
   </rule>
 
   <rule name="DoNotHardCodeSDCard"
-      since="4.2.6" language="java"
+      since="4.2.6"
+      language="java"
       message="Do not hardcode /sdcard."
       class="net.sourceforge.pmd.lang.rule.XPathRule"
-      externalInfoUrl="${pmd.website.baseurl}/rules/java/android.html#DoNotHardCodeSDCard">
+      externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_android.html#donothardcodesdcard">
     <description>Use Environment.getExternalStorageDirectory() instead of "/sdcard"</description>
     <priority>3</priority>
     <properties>
@@ -108,11 +111,11 @@ public class DummyActivity extends Activity {
     <example>
       <![CDATA[
 public class MyActivity extends Activity {
-	protected void foo() {
-		String storageLocation = "/sdcard/mypackage";	// hard-coded, poor approach
+    protected void foo() {
+        String storageLocation = "/sdcard/mypackage";   // hard-coded, poor approach
 
-		storageLocation = Environment.getExternalStorageDirectory() + "/mypackage"; // preferred approach
-	}
+       storageLocation = Environment.getExternalStorageDirectory() + "/mypackage"; // preferred approach
+    }
 }
 ]]>
     </example>
diff --git a/pmd-java/src/main/resources/rulesets/java/basic.xml b/pmd-java/src/main/resources/rulesets/java/basic.xml
index df103cd678..d0777e9d47 100644
--- a/pmd-java/src/main/resources/rulesets/java/basic.xml
+++ b/pmd-java/src/main/resources/rulesets/java/basic.xml
@@ -8,28 +8,26 @@
 The Basic ruleset contains a collection of good practices which should be followed.
   </description>
 
-	<rule name="JumbledIncrementer"
-    	  language="java"
-    	  since="1.0"
+    <rule name="JumbledIncrementer"
+          language="java"
+          since="1.0"
           message="Avoid modifying an outer loop incrementer in an inner loop for update expression"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#JumbledIncrementer">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#jumbledincrementer">
      <description>
 Avoid jumbled loop incrementers - its usually a mistake, and is confusing even if intentional.
      </description>
      <priority>3</priority>
      <properties>
          <property name="xpath">
-             <value>
- <![CDATA[
+             <value><![CDATA[
 //ForStatement
- [
-  ForUpdate/StatementExpressionList/StatementExpression/PostfixExpression/PrimaryExpression/PrimaryPrefix/Name/@Image
-  =
-  ancestor::ForStatement/ForInit//VariableDeclaratorId/@Image
- ]
- ]]>
-             </value>
+  [
+    ForUpdate/StatementExpressionList/StatementExpression/PostfixExpression/PrimaryExpression/PrimaryPrefix/Name/@Image
+    =
+    ancestor::ForStatement/ForInit//VariableDeclaratorId/@Image
+  ]
+]]></value>
          </property>
      </properties>
      <example>
@@ -43,7 +41,7 @@ public class JumbledIncrementerRule1 {
         }
     }
 }
- ]]>
+]]>
      </example>
      </rule>
 
@@ -52,31 +50,29 @@ public class JumbledIncrementerRule1 {
           since="1.02"
           message="This for loop could be simplified to a while loop"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#ForLoopShouldBeWhileLoop">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#forloopshouldbewhileloop">
       <description>
 Some for loops can be simplified to while loops, this makes them more concise.
       </description>
       <priority>3</priority>
     <properties>
         <property name="xpath">
-            <value>
-                <![CDATA[
+            <value><![CDATA[
 //ForStatement
- [count(*) > 1]
- [not(LocalVariableDeclaration)]
- [not(ForInit)]
- [not(ForUpdate)]
- [not(Type and Expression and Statement)]
- ]]>
-            </value>
+  [count(*) > 1]
+  [not(LocalVariableDeclaration)]
+  [not(ForInit)]
+  [not(ForUpdate)]
+  [not(Type and Expression and Statement)]
+]]></value>
         </property>
     </properties>
       <example>
   <![CDATA[
 public class Foo {
-	void bar() {
-		for (;true;) true; // No Init or Update part, may as well be: while (true)
-	}
+    void bar() {
+        for (;true;) true; // No Init or Update part, may as well be: while (true)
+    }
 }
  ]]>
       </example>
@@ -87,32 +83,32 @@ public class Foo {
           since="0.4"
           message="Ensure you override both equals() and hashCode()"
           class="net.sourceforge.pmd.lang.java.rule.basic.OverrideBothEqualsAndHashcodeRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#OverrideBothEqualsAndHashcode">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#overridebothequalsandhashcode">
       <description>
 Override both public boolean Object.equals(Object other), and public int Object.hashCode(), or override neither.  Even if you are inheriting a hashCode() from a parent class, consider implementing hashCode and explicitly delegating to your superclass.
       </description>
       <priority>3</priority>
       <example>
   <![CDATA[
-public class Bar {		// poor, missing a hashcode() method
-	public boolean equals(Object o) {
+public class Bar {        // poor, missing a hashcode() method
+    public boolean equals(Object o) {
       // do some comparison
-	}
+    }
 }
 
-public class Baz {		// poor, missing an equals() method
-	public int hashCode() {
+public class Baz {        // poor, missing an equals() method
+    public int hashCode() {
       // return some hash value
-	}
+    }
 }
 
-public class Foo {		// perfect, both methods provided
-	public boolean equals(Object other) {
+public class Foo {        // perfect, both methods provided
+    public boolean equals(Object other) {
       // do some comparison
-	}
-	public int hashCode() {
+    }
+    public int hashCode() {
       // return some hash value
-	}
+    }
 }
  ]]>
       </example>
@@ -123,7 +119,7 @@ public class Foo {		// perfect, both methods provided
           since="1.04"
           message="Double checked locking is not thread safe in Java."
           class="net.sourceforge.pmd.lang.java.rule.basic.DoubleCheckedLockingRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#DoubleCheckedLocking">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#doublecheckedlocking">
       <description>
 Partially created objects can be returned by the Double Checked Locking pattern when used in Java.
 An optimizing JRE may assign a reference to the baz variable before it calls the constructor of the object the
@@ -131,24 +127,24 @@ reference points to.
 
 Note: With Java 5, you can make Double checked locking work, if you declare the variable to be `volatile`.
 
-For more details refer to: http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html
-or http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
+For more details refer to: &lt;http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html>
+or &lt;http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html>
       </description>
         <priority>1</priority>
       <example>
   <![CDATA[
 public class Foo {
-	/*volatile */ Object baz = null; // fix for Java5 and later: volatile
-	Object bar() {
-		if (baz == null) { // baz may be non-null yet not fully created
-			synchronized(this) {
-				if (baz == null) {
-					baz = new Object();
-        		}
-      		}
-    	}
-		return baz;
-	}
+    /*volatile */ Object baz = null; // fix for Java5 and later: volatile
+    Object bar() {
+        if (baz == null) { // baz may be non-null yet not fully created
+            synchronized(this) {
+                if (baz == null) {
+                    baz = new Object();
+                }
+              }
+        }
+        return baz;
+    }
 }
  ]]>
       </example>
@@ -159,7 +155,7 @@ public class Foo {
           since="1.05"
           message="Avoid returning from a finally block"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#ReturnFromFinallyBlock">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#returnfromfinallyblock">
       <description>
 Avoid returning from a finally block, this can discard exceptions.
       </description>
@@ -176,15 +172,15 @@ Avoid returning from a finally block, this can discard exceptions.
       <example>
   <![CDATA[
 public class Bar {
-	public String foo() {
-		try {
-			throw new Exception( "My Exception" );
-		} catch (Exception e) {
-			throw e;
-		} finally {
-			return "A. O. K."; // return not recommended here
-		}
-	}
+    public String foo() {
+        try {
+            throw new Exception( "My Exception" );
+        } catch (Exception e) {
+            throw e;
+        } finally {
+            return "A. O. K."; // return not recommended here
+        }
+    }
 }
 ]]>
       </example>
@@ -195,7 +191,7 @@ public class Bar {
           since="1.5"
           message="Do not use 'if' statements that are always true or always false"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#UnconditionalIfStatement">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#unconditionalifstatement">
       <description>
 Do not use "if" statements whose conditionals are always true or always false.
       </description>
@@ -214,11 +210,11 @@ Do not use "if" statements whose conditionals are always true or always false.
       <example>
   <![CDATA[
 public class Foo {
-	public void close() {
-		if (true) {		// fixed conditional, not recommended
-			// ...
-		}
-	}
+    public void close() {
+        if (true) {        // fixed conditional, not recommended
+            // ...
+        }
+    }
 }
 ]]>
       </example>
@@ -228,15 +224,15 @@ public class Foo {
           since="1.2"
           message="Avoid instantiating Boolean objects; reference Boolean.TRUE or Boolean.FALSE or call Boolean.valueOf() instead."
           class="net.sourceforge.pmd.lang.java.rule.basic.BooleanInstantiationRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#BooleanInstantiation">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#booleaninstantiation">
    <description>
 Avoid instantiating Boolean objects; you can reference Boolean.TRUE, Boolean.FALSE, or call Boolean.valueOf() instead.
    </description>
       <priority>2</priority>
    <example>
    <![CDATA[
-Boolean bar = new Boolean("true");		// unnecessary creation, just reference Boolean.TRUE;
-Boolean buz = Boolean.valueOf(false);	// ...., just reference Boolean.FALSE;
+Boolean bar = new Boolean("true");        // unnecessary creation, just reference Boolean.TRUE;
+Boolean buz = Boolean.valueOf(false);    // ...., just reference Boolean.FALSE;
    ]]>
    </example>
    </rule>
@@ -246,7 +242,7 @@ Boolean buz = Boolean.valueOf(false);	// ...., just reference Boolean.FALSE;
           since="3.1"
           message="These nested if statements could be combined"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#CollapsibleIfStatements">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#collapsibleifstatements">
       <description>
 Sometimes two consecutive 'if' statements can be consolidated by separating their conditions with a boolean short-circuit operator.
       </description>
@@ -267,28 +263,28 @@ Sometimes two consecutive 'if' statements can be consolidated by separating thei
       <example>
   <![CDATA[
 void bar() {
-	if (x) {			// original implementation
-		if (y) {
-			// do stuff
-		}
-	}
+    if (x) {            // original implementation
+        if (y) {
+            // do stuff
+        }
+    }
 }
 
 void bar() {
-	if (x && y) {		// optimized implementation
-		// do stuff
-	}
+    if (x && y) {        // optimized implementation
+        // do stuff
+    }
 }
  ]]>
       </example>
     </rule>
 
-	<rule name="ClassCastExceptionWithToArray"
+    <rule name="ClassCastExceptionWithToArray"
           language="java"
           since="3.4"
           message="This usage of the Collection.toArray() method will throw a ClassCastException."
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#ClassCastExceptionWithToArray">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#classcastexceptionwithtoarray">
   <description>
 When deriving an array of a specific class from your Collection, one should provide an array of
 the same class as the parameter of the toArray() method. Doing otherwise you will will result
@@ -333,7 +329,7 @@ Integer[] b = (Integer [])c.toArray(new Integer[c.size()]);
        since="3.4"
        message="Avoid creating BigDecimal with a decimal (float/double) literal. Use a String literal"
        class="net.sourceforge.pmd.lang.rule.XPathRule"
-       externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#AvoidDecimalLiteralsInBigDecimalConstructor">
+       externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#avoiddecimalliteralsinbigdecimalconstructor">
   <description>
 One might assume that the result of "new BigDecimal(0.1)" is exactly equal to 0.1, but it is actually
 equal to .1000000000000000055511151231257827021181583404541015625.
@@ -375,22 +371,22 @@ exactly equal to 0.1, as one would expect.  Therefore, it is generally recommend
   </properties>
   <example>
 <![CDATA[
-BigDecimal bd = new BigDecimal(1.123);		// loss of precision, this would trigger the rule
+BigDecimal bd = new BigDecimal(1.123);       // loss of precision, this would trigger the rule
 
-BigDecimal bd = new BigDecimal("1.123");   	// preferred approach
+BigDecimal bd = new BigDecimal("1.123");     // preferred approach
 
-BigDecimal bd = new BigDecimal(12);     	// preferred approach, ok for integer values
+BigDecimal bd = new BigDecimal(12);          // preferred approach, ok for integer values
 ]]>
   </example>
 </rule>
 
 
     <rule  name="MisplacedNullCheck"
-    	   language="java"
+           language="java"
            since="3.5"
            message="The null check here is misplaced; if the variable is null there will be a NullPointerException"
            class="net.sourceforge.pmd.lang.rule.XPathRule"
-           externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#MisplacedNullCheck">
+           externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#misplacednullcheck">
       <description>
 The null check here is misplaced. If the variable is null a NullPointerException will be thrown.
 Either the check is useless (the variable will never be "null") or it is incorrect.
@@ -424,28 +420,28 @@ Either the check is useless (the variable will never be "null") or it is incorre
       <example>
     <![CDATA[
 public class Foo {
-	void bar() {
-		if (a.equals(baz) && a != null) {}
-		}
+    void bar() {
+        if (a.equals(baz) && a != null) {}
+        }
 }
     ]]>
       </example>
       <example><![CDATA[
 public class Foo {
-	void bar() {
-		if (a.equals(baz) || a == null) {}
-	}
+    void bar() {
+        if (a.equals(baz) || a == null) {}
+    }
 }
    ]]></example>
     </rule>
 
 
     <rule  name="AvoidThreadGroup"
-    	   language="java"
+           language="java"
            since="3.6"
            message="Avoid using java.lang.ThreadGroup; it is not thread safe"
            class="net.sourceforge.pmd.lang.rule.XPathRule"
-           externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#AvoidThreadGroup"
+           externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#avoidthreadgroup"
            typeResolution="true">
       <description>
 Avoid using java.lang.ThreadGroup; although it is intended to be used in a threaded environment
@@ -465,12 +461,12 @@ it contains methods that are not thread-safe.
       <example>
     <![CDATA[
 public class Bar {
-	void buz() {
-		ThreadGroup tg = new ThreadGroup("My threadgroup") ;
-		tg = new ThreadGroup(tg, "my thread group");
-		tg = Thread.currentThread().getThreadGroup();
-		tg = System.getSecurityManager().getThreadGroup();
-	}
+    void buz() {
+        ThreadGroup tg = new ThreadGroup("My threadgroup");
+        tg = new ThreadGroup(tg, "my thread group");
+        tg = Thread.currentThread().getThreadGroup();
+        tg = System.getSecurityManager().getThreadGroup();
+    }
 }
     ]]>
       </example>
@@ -480,7 +476,7 @@ public class Bar {
           since="3.8"
           message="Method call on object which may be null"
           class="net.sourceforge.pmd.lang.java.rule.basic.BrokenNullCheckRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#BrokenNullCheck">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#brokennullcheck">
         <description>
 The null check is broken since it will throw a NullPointerException itself.
 It is likely that you used || instead of &amp;&amp; or vice versa.
@@ -490,11 +486,11 @@ It is likely that you used || instead of &amp;&amp; or vice versa.
 <![CDATA[
 public String bar(String string) {
   // should be &&
-	if (string!=null || !string.equals(""))
-		return string;
+    if (string!=null || !string.equals(""))
+        return string;
   // should be ||
-	if (string==null && string.equals(""))
-		return string;
+    if (string==null && string.equals(""))
+        return string;
 }
         ]]>
         </example>
@@ -504,7 +500,7 @@ public String bar(String string) {
           since="3.9"
           message="Don't create instances of already existing BigInteger and BigDecimal (ZERO, ONE, TEN)"
           class="net.sourceforge.pmd.lang.java.rule.basic.BigIntegerInstantiationRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#BigIntegerInstantiation">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#bigintegerinstantiation">
   <description>
 Don't create instances of already existing BigInteger (BigInteger.ZERO, BigInteger.ONE) and
 for Java 1.5 onwards, BigInteger.TEN and BigDecimal (BigDecimal.ZERO, BigDecimal.ONE, BigDecimal.TEN)
@@ -512,11 +508,11 @@ for Java 1.5 onwards, BigInteger.TEN and BigDecimal (BigDecimal.ZERO, BigDecimal
   <priority>3</priority>
   <example>
 <![CDATA[
-BigInteger bi = new BigInteger(1);		// reference BigInteger.ONE instead
-BigInteger bi2 = new BigInteger("0");	// reference BigInteger.ZERO instead
-BigInteger bi3 = new BigInteger(0.0);	// reference BigInteger.ZERO instead
+BigInteger bi = new BigInteger(1);       // reference BigInteger.ONE instead
+BigInteger bi2 = new BigInteger("0");    // reference BigInteger.ZERO instead
+BigInteger bi3 = new BigInteger(0.0);    // reference BigInteger.ZERO instead
 BigInteger bi4;
-bi4 = new BigInteger(0);				// reference BigInteger.ZERO instead
+bi4 = new BigInteger(0);                 // reference BigInteger.ZERO instead
 ]]>
   </example>
 </rule>
@@ -525,20 +521,20 @@ bi4 = new BigInteger(0);				// reference BigInteger.ZERO instead
             since="3.9"
             message="Do not start a literal by 0 unless it's an octal value"
             class="net.sourceforge.pmd.lang.java.rule.basic.AvoidUsingOctalValuesRule"
-            externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#AvoidUsingOctalValues">
+            externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#avoidusingoctalvalues">
     <description>
-    	<![CDATA[
+        <![CDATA[
 Integer literals should not start with zero since this denotes that the rest of literal will be
 interpreted as an octal value.
-    	]]>
+        ]]>
     </description>
     <priority>3</priority>
     <example>
-		    <![CDATA[
-int i = 012;	// set i with 10 not 12
-int j = 010;	// set j with 8 not 10
-k = i * j;		// set k with 80 not 120
-		    ]]>
+            <![CDATA[
+int i = 012;    // set i with 10 not 12
+int j = 010;    // set j with 8 not 10
+k = i * j;      // set k with 80 not 120
+            ]]>
     </example>
     </rule>
 
@@ -546,32 +542,32 @@ k = i * j;		// set k with 80 not 120
             since="4.1"
             message="Do not hard code the IP address ${variableName}"
             class="net.sourceforge.pmd.lang.java.rule.basic.AvoidUsingHardCodedIPRule"
-            externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#AvoidUsingHardCodedIP">
-	    <description>
-	    	<![CDATA[
+            externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#avoidusinghardcodedip">
+        <description>
+            <![CDATA[
 Application with hard-coded IP addresses can become impossible to deploy in some cases.
 Externalizing IP adresses is preferable.
-	    	]]>
-	    </description>
-	    <priority>3</priority>
-	     <properties>
+            ]]>
+        </description>
+        <priority>3</priority>
+         <properties>
             <property name="pattern" type="String" description="Regular Expression" value='^"[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}"$'/>
         </properties>
-	    <example>
-	    <![CDATA[
+        <example>
+        <![CDATA[
 public class Foo {
-	private String ip = "127.0.0.1"; 	// not recommended
+    private String ip = "127.0.0.1";     // not recommended
 }
-	    ]]>
-	    </example>
+        ]]>
+        </example>
     </rule>
 
   <rule name="CheckResultSet"
-    	language="java"
+        language="java"
         since="4.1"
         class="net.sourceforge.pmd.lang.java.rule.basic.CheckResultSetRule"
         message="Always check the return of one of the navigation method (next,previous,first,last) of a ResultSet."
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#CheckResultSet">
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#checkresultset">
         <description>
             <![CDATA[
 Always check the return values of navigation methods (next, previous, first, last) of a ResultSet.
@@ -583,25 +579,25 @@ If the value return is 'false', it should be handled properly.
             <![CDATA[
 Statement stat = conn.createStatement();
 ResultSet rst = stat.executeQuery("SELECT name FROM person");
-rst.next(); 	// what if it returns false? bad form
+rst.next();     // what if it returns false? bad form
 String firstName = rst.getString(1);
 
 Statement stat = conn.createStatement();
 ResultSet rst = stat.executeQuery("SELECT name FROM person");
-if (rst.next()) {	// result is properly examined and used
+if (rst.next()) {    // result is properly examined and used
     String firstName = rst.getString(1);
-	} else  {
-		// handle missing data
+    } else  {
+        // handle missing data
 }
             ]]>
         </example>
     </rule>
 
-	<rule name="AvoidMultipleUnaryOperators"
-		  since="4.2"
-		  class="net.sourceforge.pmd.lang.java.rule.basic.AvoidMultipleUnaryOperatorsRule"
-		  message="Using multiple unary operators may be a bug, and/or is confusing."
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#AvoidMultipleUnaryOperators">
+    <rule name="AvoidMultipleUnaryOperators"
+          since="4.2"
+          class="net.sourceforge.pmd.lang.java.rule.basic.AvoidMultipleUnaryOperatorsRule"
+          message="Using multiple unary operators may be a bug, and/or is confusing."
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#avoidmultipleunaryoperators">
         <description>
             <![CDATA[
 The use of multiple unary operators may be problematic, and/or confusing.
@@ -633,11 +629,11 @@ int j = -~7;
     </rule>
 
   <rule name="ExtendsObject"
-  		language="java"
+        language="java"
         since="5.0"
         message="No need to explicitly extend Object."
         class="net.sourceforge.pmd.lang.rule.XPathRule"
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#ExtendsObject">
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#extendsobject">
     <description>No need to explicitly extend Object.</description>
     <priority>4</priority>
     <properties>
@@ -651,18 +647,18 @@ int j = -~7;
     </properties>
     <example>
     <![CDATA[
-public class Foo extends Object { 	// not required
+public class Foo extends Object {     // not required
 }
     ]]>
     </example>
   </rule>
 
-	<rule name="CheckSkipResult"
-	      language="java"
-	  	  since="5.0"
+    <rule name="CheckSkipResult"
+          language="java"
+          since="5.0"
           message="Check the value returned by the skip() method of an InputStream to see if the requested number of bytes has been skipped."
           class="net.sourceforge.pmd.lang.java.rule.basic.CheckSkipResultRule"
-	  	  externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#CheckSkipResult">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#checkskipresult">
         <description>The skip() method may skip a smaller number of bytes than requested. Check the returned value to find out if it was the case or not.</description>
         <priority>3</priority>
         <example>
@@ -687,11 +683,11 @@ public class Foo {
         </example>
     </rule>
 
-	<rule name="AvoidBranchingStatementAsLastInLoop"
-	  	  since="5.0"
-		  class="net.sourceforge.pmd.lang.java.rule.basic.AvoidBranchingStatementAsLastInLoopRule"
-		  message="Avoid using a branching statement as the last in a loop."
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#AvoidBranchingStatementAsLastInLoop">
+    <rule name="AvoidBranchingStatementAsLastInLoop"
+            since="5.0"
+          class="net.sourceforge.pmd.lang.java.rule.basic.AvoidBranchingStatementAsLastInLoopRule"
+          message="Avoid using a branching statement as the last in a loop."
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#avoidbranchingstatementaslastinloop">
         <description>
             <![CDATA[
 Using a branching statement as the last part of a loop may be a bug, and/or is confusing.
@@ -703,17 +699,17 @@ Ensure that the usage is not a bug, or consider using another approach.
             <![CDATA[
   // unusual use of branching statement in a loop
 for (int i = 0; i < 10; i++) {
-	if (i*i <= 25) {
-		continue;
-	}
-	break;
+    if (i*i <= 25) {
+        continue;
+    }
+    break;
 }
 
   // this makes more sense...
 for (int i = 0; i < 10; i++) {
-	if (i*i > 25) {
-		break;
-	}
+    if (i*i > 25) {
+        break;
+    }
 }
             ]]>
         </example>
@@ -724,7 +720,7 @@ for (int i = 0; i < 10; i++) {
            since="4.3"
            message="Don't call Thread.run() explicitly, use Thread.start()"
            class="net.sourceforge.pmd.lang.rule.XPathRule"
-           externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#DontCallThreadRun">
+           externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#dontcallthreadrun">
       <description>
 Explicitly calling Thread.run() method will execute in the caller's thread of control.  Instead, call Thread.start() for the intended behavior.
       </description>
@@ -763,7 +759,7 @@ new Thread().run(); // same violation
          since="4.3"
          message="Don't use floating point for loop indices. If you must use floating point, use double."
          class="net.sourceforge.pmd.lang.rule.XPathRule"
-         externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#DontUseFloatTypeForLoopIndices">
+         externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#dontusefloattypeforloopindices">
     <description>
 Don't use floating point for loop indices. If you must use floating point, use double
 unless you're certain that float provides enough precision and you have a compelling
@@ -802,7 +798,7 @@ public class Count {
     since="5.4.0"
     message="Ternary operators that can be simplified with || or &amp;&amp;"
     class="net.sourceforge.pmd.lang.rule.XPathRule"
-    externalInfoUrl="${pmd.website.baseurl}/rules/java/basic.html#SimplifiedTernary">
+    externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_basic.html#simplifiedternary">
     <description>
         <![CDATA[
 Look for ternary operators with the form `condition ? literalBoolean : foo`
diff --git a/pmd-java/src/main/resources/rulesets/java/braces.xml b/pmd-java/src/main/resources/rulesets/java/braces.xml
index dd2ce85640..aa7be0d313 100644
--- a/pmd-java/src/main/resources/rulesets/java/braces.xml
+++ b/pmd-java/src/main/resources/rulesets/java/braces.xml
@@ -9,11 +9,11 @@ The Braces ruleset contains rules regarding the use and placement of braces.
   </description>
 
    <rule name="IfStmtsMustUseBraces"
-   		language="java"
-   		since="1.0"
+         language="java"
+         since="1.0"
          message="Avoid using if statements without curly braces"
          class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/braces.html#IfStmtsMustUseBraces">
+         externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_braces.html#ifstmtsmustusebraces">
      <description>
 Avoid using if statements without using braces to surround the code block. If the code 
 formatting or indentation is lost then it becomes difficult to separate the code being
@@ -31,12 +31,11 @@ controlled from the rest.
        </properties>
      <example>
  <![CDATA[
+if (foo)    // not recommended
+    x++;
 
-if (foo)	// not recommended
-	x++;
-
-if (foo) {	// preferred approach
-	x++;
+if (foo) {  // preferred approach
+    x++;
 }
 
  ]]>
@@ -44,11 +43,11 @@ if (foo) {	// preferred approach
      </rule>
 
     <rule name="WhileLoopsMustUseBraces"
-   		language="java"
-    		 since="0.7"
+          language="java"
+          since="0.7"
           message="Avoid using 'while' statements without curly braces"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/braces.html#WhileLoopsMustUseBraces">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_braces.html#whileloopsmustusebraces">
       <description>
 Avoid using 'while' statements without using braces to surround the code block. If the code 
 formatting or indentation is lost then it becomes difficult to separate the code being
@@ -66,10 +65,10 @@ controlled from the rest.
         </properties>
       <example>
 <![CDATA[
-while (true)	// not recommended
+while (true)    // not recommended
       x++;
       
-while (true) {	// preferred approach
+while (true) {  // preferred approach
       x++;
 }
 ]]>
@@ -81,7 +80,7 @@ while (true) {	// preferred approach
             since="0.2"
             message="Avoid using 'if...else' statements without curly braces"
             class="net.sourceforge.pmd.lang.rule.XPathRule"
-            externalInfoUrl="${pmd.website.baseurl}/rules/java/braces.html#IfElseStmtsMustUseBraces">
+            externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_braces.html#ifelsestmtsmustusebraces">
        <description>
 Avoid using if..else statements without using surrounding braces. If the code formatting 
 or indentation is lost then it becomes difficult to separate the code being controlled 
@@ -104,7 +103,7 @@ from the rest.
 <![CDATA[
    // this is OK
 if (foo) x++;
-   
+
    // but this is not
 if (foo)
        x = x+1;
@@ -119,7 +118,7 @@ if (foo)
            since="0.7"
            message="Avoid using 'for' statements without curly braces"
            class="net.sourceforge.pmd.lang.rule.XPathRule"
-           externalInfoUrl="${pmd.website.baseurl}/rules/java/braces.html#ForLoopsMustUseBraces">
+           externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_braces.html#forloopsmustusebraces">
        <description>
 Avoid using 'for' statements without using curly braces. If the code formatting or 
 indentation is lost then it becomes difficult to separate the code being controlled 
diff --git a/pmd-java/src/main/resources/rulesets/java/clone.xml b/pmd-java/src/main/resources/rulesets/java/clone.xml
index 5f5915e8f9..01350d2b5d 100644
--- a/pmd-java/src/main/resources/rulesets/java/clone.xml
+++ b/pmd-java/src/main/resources/rulesets/java/clone.xml
@@ -9,11 +9,11 @@ The Clone Implementation ruleset contains a collection of rules that find questi
   </description>
 
     <rule name="ProperCloneImplementation"
-   		language="java"
-    		since="1.4"
-         message="Object clone() should be implemented with super.clone()"
-         class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/clone.html#ProperCloneImplementation">
+          language="java"
+          since="1.4"
+          message="Object clone() should be implemented with super.clone()"
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_clone.html#propercloneimplementation">
      <description>
 Object clone() should be implemented with super.clone().
      </description>
@@ -47,11 +47,11 @@ class Foo{
      </rule>
 
     <rule name="CloneThrowsCloneNotSupportedException"
-   		language="java"
-    		since="1.9"
-         message="clone() method should throw CloneNotSupportedException"
-         class="net.sourceforge.pmd.lang.rule.XPathRule"
-         externalInfoUrl="${pmd.website.baseurl}/rules/java/clone.html#CloneThrowsCloneNotSupportedException">
+          language="java"
+          since="1.9"
+          message="clone() method should throw CloneNotSupportedException"
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_clone.html#clonethrowsclonenotsupportedexception">
          <description>
 The method clone() should throw a CloneNotSupportedException.
          </description>
@@ -76,22 +76,22 @@ and count(NameList/Name[contains
          </properties>
          <example>
              <![CDATA[
- public class MyClass implements Cloneable{
-     public Object clone() { // will cause an error
-          MyClass clone = (MyClass)super.clone();
-          return clone;
-     }
- }
+public class MyClass implements Cloneable{
+    public Object clone() { // will cause an error
+         MyClass clone = (MyClass)super.clone();
+         return clone;
+    }
+}
     ]]>
          </example>
      </rule>
 
     <rule name="CloneMethodMustImplementCloneable"
-   		language="java"
-    	  since="1.9"
-        message="clone() method should be implemented only if implementing Cloneable interface"
-        class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/clone.html#CloneMethodMustImplementCloneable">
+          language="java"
+          since="1.9"
+          message="clone() method should be implemented only if implementing Cloneable interface"
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_clone.html#clonemethodmustimplementcloneable">
         <description>
 The method clone() should only be implemented if the class implements the Cloneable interface with the exception of a final method that only throws CloneNotSupportedException.
         </description>
@@ -112,7 +112,6 @@ and Block[count(BlockStatement)=1]
 /BlockStatement/Statement/ThrowStatement/Expression
 /PrimaryExpression/PrimaryPrefix/AllocationExpression
 /ClassOrInterfaceType[@Image = 'CloneNotSupportedException'])]]
-
                     ]]>
                 </value>
             </property>
@@ -134,7 +133,7 @@ public class MyClass {
         since="5.4.0"
         message="The return type of the clone() method must be the class name when implements Cloneable"
         class="net.sourceforge.pmd.lang.rule.XPathRule"
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/clone.html#CloneMethodReturnTypeMustMatchClassName">
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_clone.html#clonemethodreturntypemustmatchclassname">
         <description>
 If a class implements cloneable the return type of the method clone() must be the class name. That way, the caller
 of the clone method doesn't need to cast the returned clone to the correct type.
@@ -178,7 +177,7 @@ public class Foo implements Cloneable {
         since="5.4.0"
         message="clone() method must be public if the class implements Cloneable"
         class="net.sourceforge.pmd.lang.rule.XPathRule"
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/clone.html#CloneMethodMustBePublic">
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_clone.html#clonemethodmustbepublic">
         <description>
 The java Manual says "By convention, classes that implement this interface should override
 Object.clone (which is protected) with a public method."
@@ -189,10 +188,8 @@ Object.clone (which is protected) with a public method."
                 <value>
                     <![CDATA[
 //MethodDeclaration[@Public='false']
-[
-MethodDeclarator/@Image = 'clone'
-and MethodDeclarator/FormalParameters/@ParameterCount = 0
-]
+  [MethodDeclarator/@Image = 'clone']
+  [MethodDeclarator/FormalParameters/@ParameterCount = 0]
                     ]]>
                 </value>
             </property>
diff --git a/pmd-java/src/main/resources/rulesets/java/codesize.xml b/pmd-java/src/main/resources/rulesets/java/codesize.xml
index 6f109353bf..1eb9106450 100644
--- a/pmd-java/src/main/resources/rulesets/java/codesize.xml
+++ b/pmd-java/src/main/resources/rulesets/java/codesize.xml
@@ -13,7 +13,7 @@ The Code Size ruleset contains rules that find problems related to code size or
       since="3.9"
       message="The method {0}() has an NPath complexity of {1}"
       class="net.sourceforge.pmd.lang.java.rule.codesize.NPathComplexityRule"
-      externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#NPathComplexity">
+      externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#npathcomplexity">
    <description>
 The NPath complexity of a method is the number of acyclic execution paths through that method.
 A threshold of 200 is generally considered the point where measures should be taken to reduce 
@@ -22,44 +22,42 @@ complexity and increase readability.
      <priority>3</priority>
     <example>
  <![CDATA[
-void bar() {	// this is something more complex than it needs to be,
-	if (y) {	// it should be broken down into smaller methods or functions
-		for (j = 0; j < m; j++) {
-			if (j > r) {
-				doSomething();
-				while (f < 5 ) {
-					anotherThing();
-					f -= 27;
-					}
-				} else {
-					tryThis();
-				}
-			}
-		}
-		if ( r - n > 45) {
-		   while (doMagic()) {
-		      findRabbits();
-		   }
-		}
-		try {
-			doSomethingDangerous();
-		} catch (Exception ex) {
-			makeAmends();
-			} finally {
-				dontDoItAgain();
-				}
-	}
+void bar() {    // this is something more complex than it needs to be,
+    if (y) {   // it should be broken down into smaller methods or functions
+        for (j = 0; j < m; j++) {
+            if (j > r) {
+                doSomething();
+                while (f < 5 ) {
+                    anotherThing();
+                    f -= 27;
+                }
+            } else {
+                tryThis();
+            }
+        }
+    }
+    if ( r - n > 45) {
+       while (doMagic()) {
+          findRabbits();
+       }
+    }
+    try {
+        doSomethingDangerous();
+    } catch (Exception ex) {
+        makeAmends();
+    } finally {
+        dontDoItAgain();
+    }
 }
-
  ]]>
     </example>
 </rule>
 
  <rule name="ExcessiveMethodLength"
- 		 since="0.6"
+       since="0.6"
        message="Avoid really long methods."
        class="net.sourceforge.pmd.lang.java.rule.codesize.ExcessiveMethodLengthRule"
-       externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#ExcessiveMethodLength">
+       externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#excessivemethodlength">
    <description>
 When methods are excessively long this usually indicates that the method is doing more than its
 name/signature might suggest. They also become challenging for others to digest since excessive 
@@ -70,22 +68,20 @@ Try to reduce the method length by creating helper methods and removing any copy
    <example>
 <![CDATA[
 public void doSomething() {
-	System.out.println("Hello world!");
-	System.out.println("Hello world!");
-		// 98 copies omitted for brevity.
+    System.out.println("Hello world!");
+    System.out.println("Hello world!");
+    // 98 copies omitted for brevity.
 }
-
 ]]>
    </example>
-
  </rule>
 
 
  <rule name="ExcessiveParameterList"
- 		 since="0.9"
+       since="0.9"
        message="Avoid long parameter lists."
        class="net.sourceforge.pmd.lang.java.rule.codesize.ExcessiveParameterListRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#ExcessiveParameterList">
+       externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#excessiveparameterlist">
    <description>
 Methods with numerous parameters are a challenge to maintain, especially if most of them share the
 same datatype. These situations usually denote the need for new objects to wrap the numerous parameters.
@@ -93,16 +89,16 @@ same datatype. These situations usually denote the need for new objects to wrap
      <priority>3</priority>
    <example>
 <![CDATA[
-public void addPerson(		// too many arguments liable to be mixed up
-	int birthYear, int birthMonth, int birthDate, int height, int weight, int ssn) {
+public void addPerson(      // too many arguments liable to be mixed up
+    int birthYear, int birthMonth, int birthDate, int height, int weight, int ssn) {
 
-	. . . .
+    . . . .
 }
  
-public void addPerson(		// preferred approach
-	Date birthdate, BodyMeasurements measurements, int ssn) {
+public void addPerson(      // preferred approach
+    Date birthdate, BodyMeasurements measurements, int ssn) {
 
-	. . . .
+    . . . .
 }
 ]]>
    </example>
@@ -111,57 +107,54 @@ public void addPerson(		// preferred approach
 
 
  <rule name="ExcessiveClassLength"
- 		 since="0.6"
+       since="0.6"
        message="Avoid really long classes."
        class="net.sourceforge.pmd.lang.java.rule.codesize.ExcessiveClassLengthRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#ExcessiveClassLength">
+       externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#excessiveclasslength">
    <description>
 Excessive class file lengths are usually indications that the class may be burdened with excessive 
 responsibilities that could be provided by external classes or functions. In breaking these methods
-apart the code becomes more managable and ripe for reuse.
+apart the code becomes more manageable and ripe for reuse.
    </description>
      <priority>3</priority>
    <example>
 <![CDATA[
 public class Foo {
-	public void bar1() {
-    // 1000 lines of code
-	}
-	public void bar2() {
-    // 1000 lines of code
-	}
+    public void bar1() {
+        // 1000 lines of code
+    }
+    public void bar2() {
+        // 1000 lines of code
+    }
     public void bar3() {
-    // 1000 lines of code
-	}
-	
-	
+        // 1000 lines of code
+    }
+
     public void barN() {
-    // 1000 lines of code
-	}
+        // 1000 lines of code
+    }
 }
 ]]>
    </example>
  </rule>
 
 
-    <rule 	name="CyclomaticComplexity"
-    			since="1.03"
-      		message = "The {0} ''{1}'' has a Cyclomatic Complexity of {2}."
-	      	class="net.sourceforge.pmd.lang.java.rule.codesize.CyclomaticComplexityRule"
-	      	externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#CyclomaticComplexity"
-	      	deprecated="true">
+    <rule name="CyclomaticComplexity"
+          since="1.03"
+          message = "The {0} ''{1}'' has a Cyclomatic Complexity of {2}."
+          class="net.sourceforge.pmd.lang.java.rule.codesize.CyclomaticComplexityRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#cyclomaticcomplexity"
+          deprecated="true">
    <description>
-   		<![CDATA[
 Complexity directly affects maintenance costs is determined by the number of decision points in a method 
 plus one for the method entry.  The decision points include 'if', 'while', 'for', and 'case labels' calls.  
 Generally, numbers ranging from 1-4 denote low complexity, 5-7 denote moderate complexity, 8-10 denote
 high complexity, and 11+ is very high complexity.
-		]]>
    </description>
    <priority>3</priority>
    <example>
 <![CDATA[
-public class Foo {		// This has a Cyclomatic Complexity = 12
+public class Foo {      // This has a Cyclomatic Complexity = 12
 1   public void example()  {
 2       if (a == b)  {
 3           if (a1 == b1) {
@@ -201,19 +194,17 @@ public class Foo {		// This has a Cyclomatic Complexity = 12
    </example>
 </rule>
 
-    <rule   name="StdCyclomaticComplexity"
+    <rule name="StdCyclomaticComplexity"
           since="5.1.2"
           message = "The {0} ''{1}'' has a Standard Cyclomatic Complexity of {2}."
           class="net.sourceforge.pmd.lang.java.rule.codesize.StdCyclomaticComplexityRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#StdCyclomaticComplexity"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#stdcyclomaticcomplexity"
           deprecated="true">
    <description>
-      <![CDATA[
 Complexity directly affects maintenance costs is determined by the number of decision points in a method 
 plus one for the method entry.  The decision points include 'if', 'while', 'for', and 'case labels' calls.  
 Generally, numbers ranging from 1-4 denote low complexity, 5-7 denote moderate complexity, 8-10 denote
 high complexity, and 11+ is very high complexity.
-    ]]>
    </description>
    <priority>3</priority>
    <example>
@@ -258,20 +249,18 @@ public class Foo {    // This has a Cyclomatic Complexity = 12
    </example>
 </rule>
 
-    <rule   name="ModifiedCyclomaticComplexity"
+    <rule name="ModifiedCyclomaticComplexity"
           since="5.1.2"
           message = "The {0} ''{1}'' has a Modified Cyclomatic Complexity of {2}."
           class="net.sourceforge.pmd.lang.java.rule.codesize.ModifiedCyclomaticComplexityRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#ModifiedCyclomaticComplexity"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#modifiedcyclomaticcomplexity"
           deprecated="true">
    <description>
-      <![CDATA[
 Complexity directly affects maintenance costs is determined by the number of decision points in a method 
 plus one for the method entry.  The decision points include 'if', 'while', 'for', and 'case labels' calls.  
 Generally, numbers ranging from 1-4 denote low complexity, 5-7 denote moderate complexity, 8-10 denote
 high complexity, and 11+ is very high complexity. Modified complexity treats switch statements as a single
 decision point.
-    ]]>
    </description>
    <priority>3</priority>
    <example>
@@ -317,10 +306,10 @@ public class Foo {    // This has a Cyclomatic Complexity = 9
 </rule>
 
     <rule name="ExcessivePublicCount"
-    since="1.04"
-    message="This class has a bunch of public methods and attributes"
-    class="net.sourceforge.pmd.lang.java.rule.codesize.ExcessivePublicCountRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#ExcessivePublicCount">
+          since="1.04"
+          message="This class has a bunch of public methods and attributes"
+          class="net.sourceforge.pmd.lang.java.rule.codesize.ExcessivePublicCountRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#excessivepubliccount">
     <description>
 Classes with large numbers of public methods and attributes require disproportionate testing efforts
 since combinational side effects grow rapidly and increase risk. Refactoring these classes into
@@ -331,25 +320,25 @@ developed easily.
     <example>
     <![CDATA[
 public class Foo {
-	public String value;
-	public Bar something;
-	public Variable var;
- // [... more more public attributes ...]
- 
-	public void doWork() {}
-	public void doMoreWork() {}
-	public void doWorkAgain() {}
- // [... more more public methods ...]
+    public String value;
+    public Bar something;
+    public Variable var;
+    // [... more more public attributes ...]
+
+    public void doWork() {}
+    public void doMoreWork() {}
+    public void doWorkAgain() {}
+    // [... more more public methods ...]
 }
     ]]>
     </example>
     </rule>
 
     <rule name="TooManyFields"
-    		 since="3.0"
+          since="3.0"
           message="Too many fields"
           class="net.sourceforge.pmd.lang.java.rule.codesize.TooManyFieldsRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#TooManyFields">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#toomanyfields">
       <description>
 Classes that have too many fields can become unwieldy and could be redesigned to have fewer fields,
 possibly through grouping related fields in new objects.  For example, a class with individual 
@@ -358,7 +347,7 @@ city/state/zip fields could park them within a single Address field.
         <priority>3</priority>
       <example>
    <![CDATA[
-public class Person {	// too many separate fields
+public class Person {   // too many separate fields
    int birthYear;
    int birthMonth;
    int birthDate;
@@ -366,7 +355,7 @@ public class Person {	// too many separate fields
    float weight;
 }
 
-public class Person {	// this is more manageable
+public class Person {   // this is more manageable
    Date birthDate;
    BodyMeasurements measurements;
 }
@@ -374,10 +363,11 @@ public class Person {	// this is more manageable
       </example>
     </rule>
 
-<rule name="NcssMethodCount" message="The method {0}() has an NCSS line count of {1}"
-   since="3.9"
-   class="net.sourceforge.pmd.lang.java.rule.codesize.NcssMethodCountRule"
-   externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#NcssMethodCount">
+<rule name="NcssMethodCount"
+      message="The method {0}() has an NCSS line count of {1}"
+     since="3.9"
+     class="net.sourceforge.pmd.lang.java.rule.codesize.NcssMethodCountRule"
+     externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#ncssmethodcount">
     <description>
 This rule uses the NCSS (Non-Commenting Source Statements) algorithm to determine the number of lines
 of code for a given method. NCSS ignores comments, and counts actual statements. Using this algorithm,
@@ -387,25 +377,25 @@ lines of code that are split are counted as one.
    <example>
 <![CDATA[
 public class Foo extends Bar {
- public int methd() {
-     super.methd();
+    public int methd() {
+        super.methd();
 
 
 
 
-
- //this method only has 1 NCSS lines
-      return 1;
- }
+        //this method only has 1 NCSS lines
+        return 1;
+    }
 }
 ]]>
    </example>
    </rule>
 
-<rule name="NcssTypeCount" message="The type has an NCSS line count of {0}"
-   since="3.9"
-   class="net.sourceforge.pmd.lang.java.rule.codesize.NcssTypeCountRule"
-   externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#NcssTypeCount">
+<rule name="NcssTypeCount"
+      message="The type has an NCSS line count of {0}"
+     since="3.9"
+     class="net.sourceforge.pmd.lang.java.rule.codesize.NcssTypeCountRule"
+     externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#ncsstypecount">
     <description>
 This rule uses the NCSS (Non-Commenting Source Statements) algorithm to determine the number of lines
 of code for a given type. NCSS ignores comments, and counts actual statements. Using this algorithm,
@@ -415,24 +405,25 @@ lines of code that are split are counted as one.
    <example>
 <![CDATA[
 public class Foo extends Bar {
- public Foo() {
- //this class only has 6 NCSS lines
-     super();
+    public Foo() {
+        //this class only has 6 NCSS lines
+        super();
 
 
 
 
 
-      super.foo();
- }
+        super.foo();
+    }
 }
 ]]>
    </example></rule>
 
-<rule name="NcssConstructorCount" message="The constructor with {0} parameters has an NCSS line count of {1}"
-   since="3.9"
-   class="net.sourceforge.pmd.lang.java.rule.codesize.NcssConstructorCountRule"
-   externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#NcssConstructorCount">
+<rule name="NcssConstructorCount"
+      message="The constructor with {0} parameters has an NCSS line count of {1}"
+      since="3.9"
+      class="net.sourceforge.pmd.lang.java.rule.codesize.NcssConstructorCountRule"
+      externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#ncssconstructorcount">
     <description>
 This rule uses the NCSS (Non-Commenting Source Statements) algorithm to determine the number of lines
 of code for a given constructor. NCSS ignores comments, and counts actual statements. Using this algorithm,
@@ -442,16 +433,16 @@ lines of code that are split are counted as one.
    <example>
 <![CDATA[
 public class Foo extends Bar {
- public Foo() {
-     super();
+    public Foo() {
+        super();
 
 
 
 
 
- //this constructor only has 1 NCSS lines
-      super.foo();
- }
+        //this constructor only has 1 NCSS lines
+        super.foo();
+    }
 }
 ]]>
    </example>
@@ -459,16 +450,14 @@ public class Foo extends Bar {
 
     <rule
         name="TooManyMethods"
-   		language="java"
+        language="java"
         since="4.2"
         class="net.sourceforge.pmd.lang.rule.XPathRule"
         message="This class has too many methods, consider refactoring it."
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/codesize.html#TooManyMethods">
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_codesize.html#toomanymethods">
         <description>
-            <![CDATA[
-A class with too many methods is probably a good suspect for refactoring, in order to reduce its complexity and find a way to
-have more fine grained objects.
-            ]]>
+A class with too many methods is probably a good suspect for refactoring, in order to reduce its
+complexity and find a way to have more fine grained objects.
         </description>
         <priority>3</priority>
         <properties>
diff --git a/pmd-java/src/main/resources/rulesets/java/comments.xml b/pmd-java/src/main/resources/rulesets/java/comments.xml
index 42dad25e12..1a45408802 100755
--- a/pmd-java/src/main/resources/rulesets/java/comments.xml
+++ b/pmd-java/src/main/resources/rulesets/java/comments.xml
@@ -10,10 +10,10 @@ Rules intended to catch errors related to code comments
   </description>
 
    <rule name="CommentRequired"
-    		  since="5.1"
-        message="Comment is required"
-        class="net.sourceforge.pmd.lang.java.rule.comments.CommentRequiredRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/comments.html#CommentRequired">
+         since="5.1"
+         message="Comment is required"
+         class="net.sourceforge.pmd.lang.java.rule.comments.CommentRequiredRule"
+         externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_comments.html#commentrequired">
     <description>
 Denotes whether comments are required (or unwanted) for specific language elements.
     </description>
@@ -23,17 +23,17 @@ Denotes whether comments are required (or unwanted) for specific language elemen
 /**
 * 
 *
-* @author George Bush
+* @author Jon Doe
 */
 ]]>
     </example>
   </rule>
   
     <rule name="CommentSize"
-    		  since="5.0"
-        message="Comment is too large"
-        class="net.sourceforge.pmd.lang.java.rule.comments.CommentSizeRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/comments.html#CommentSize">
+          since="5.0"
+          message="Comment is too large"
+          class="net.sourceforge.pmd.lang.java.rule.comments.CommentSizeRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_comments.html#commentsize">
     <description>
 Determines whether the dimensions of non-header comments found are within the specified limits.
     </description>
@@ -42,7 +42,7 @@ Determines whether the dimensions of non-header comments found are within the sp
 <![CDATA[
 /**
 *
-*	too many lines!
+*   too many lines!
 *
 *
 *
@@ -61,26 +61,26 @@ Determines whether the dimensions of non-header comments found are within the sp
   </rule>
 
   <rule name="CommentContent"
-    		  since="5.0"
-     message="Invalid words or phrases found"
-     class="net.sourceforge.pmd.lang.java.rule.comments.CommentContentRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/comments.html#CommentContent">
+        since="5.0"
+        message="Invalid words or phrases found"
+        class="net.sourceforge.pmd.lang.java.rule.comments.CommentContentRule"
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_comments.html#commentcontent">
      <description>
 A rule for the politically correct... we don't want to offend anyone.
   </description>
   <priority>3</priority>
   <example>
       <![CDATA[
-//	OMG, this is horrible, Bob is an idiot !!!
+//OMG, this is horrible, Bob is an idiot !!!
       ]]>
   </example>
    </rule>
 
   <rule name="CommentDefaultAccessModifier"
-      since="5.4.0"
-      class="net.sourceforge.pmd.lang.java.rule.comments.CommentDefaultAccessModifierRule"
-      message="Missing commented default access modifier"
-      externalInfoUrl="${pmd.website.baseurl}/rules/java/comments.html#CommentDefaultAccessModifier">
+        since="5.4.0"
+        class="net.sourceforge.pmd.lang.java.rule.comments.CommentDefaultAccessModifierRule"
+        message="Missing commented default access modifier"
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_comments.html#commentdefaultaccessmodifier">
     <description>
         To avoid mistakes if we want that a Method, Constructor, Field or Nested class have a default access modifier
         we must add a comment at the beginning of it's declaration.
diff --git a/pmd-java/src/main/resources/rulesets/java/controversial.xml b/pmd-java/src/main/resources/rulesets/java/controversial.xml
index d704db9ae3..1e7b42380d 100644
--- a/pmd-java/src/main/resources/rulesets/java/controversial.xml
+++ b/pmd-java/src/main/resources/rulesets/java/controversial.xml
@@ -11,14 +11,14 @@ They are held here to allow people to include them as they see fit within their
   </description>
 
     <rule name="UnnecessaryConstructor"
-       language="java"
-         since="1.0"
+          language="java"
+          since="1.0"
           message="Avoid unnecessary constructors - the compiler will generate these for you"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#UnnecessaryConstructor">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#unnecessaryconstructor">
       <description>
 This rule detects when a constructor is not necessary; i.e., when there is only one constructor,
-its public, has an empty body, and takes no arguments.
+it's public, has an empty body, and takes no arguments.
       </description>
       <priority>3</priority>
         <properties>
@@ -46,10 +46,10 @@ public class Foo {
     </rule>
 
     <rule name="NullAssignment"
-         since="1.02"
+          since="1.02"
           message="Assigning an Object to null is a code smell.  Consider refactoring."
           class="net.sourceforge.pmd.lang.java.rule.controversial.NullAssignmentRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#NullAssignment">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#nullassignment">
       <description>
 Assigning a "null" to a variable (outside of its declaration) is usually bad form.  Sometimes, this type
 of assignment is an indication that the programmer doesn't completely understand what is going on in the code.
@@ -72,10 +72,10 @@ public void bar() {
     </rule>
 
     <rule name="OnlyOneReturn"
-        since="1.0"
-         message="A method should have only one exit point, and that should be the last statement in the method"
-         class="net.sourceforge.pmd.lang.java.rule.controversial.OnlyOneReturnRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#OnlyOneReturn">
+          since="1.0"
+          message="A method should have only one exit point, and that should be the last statement in the method"
+          class="net.sourceforge.pmd.lang.java.rule.controversial.OnlyOneReturnRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#onlyonereturn">
      <description>
 A method should have only one exit point, and that should be the last statement in the method.
      </description>
@@ -95,10 +95,10 @@ public class OneReturnOnly1 {
      </rule>
 
     <rule name="AssignmentInOperand"
-      since="1.03"
-      message="Avoid assignments in operands"
-      class="net.sourceforge.pmd.lang.java.rule.controversial.AssignmentInOperandRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AssignmentInOperand">
+          since="1.03"
+          message="Avoid assignments in operands"
+          class="net.sourceforge.pmd.lang.java.rule.controversial.AssignmentInOperandRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#assignmentinoperand">
   <description>
 Avoid assignments in operands; this can make code more complicated and harder to read.
   </description>
@@ -116,11 +116,11 @@ public void bar() {
 </rule>
 
     <rule name="AtLeastOneConstructor"
-       language="java"
-      since="1.04"
-      message="Each class should declare at least one constructor"
-      class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AtLeastOneConstructor">
+          language="java"
+          since="1.04"
+          message="Each class should declare at least one constructor"
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#atleastoneconstructor">
   <description>
 Each class should declare at least one constructor.
   </description>
@@ -153,10 +153,10 @@ public class Foo {
 </rule>
 
     <rule name="DontImportSun"
-       since="1.5"
-       message="Avoid importing anything from the 'sun.*' packages"
-       class="net.sourceforge.pmd.lang.java.rule.controversial.DontImportSunRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#DontImportSun">
+          since="1.5"
+          message="Avoid importing anything from the 'sun.*' packages"
+          class="net.sourceforge.pmd.lang.java.rule.controversial.DontImportSunRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#dontimportsun">
        <description>
 Avoid importing anything from the 'sun.*' packages.  These packages are not portable and are likely to change.
        </description>
@@ -170,17 +170,17 @@ public class Foo {}
     </rule>
 
     <rule name="SuspiciousOctalEscape"
-       since="1.5"
-       message="Suspicious decimal characters following octal escape in string literal"
+          since="1.5"
+          message="Suspicious decimal characters following octal escape in string literal"
           class="net.sourceforge.pmd.lang.java.rule.controversial.SuspiciousOctalEscapeRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#SuspiciousOctalEscape">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#suspiciousoctalescape">
       <description>
 A suspicious octal escape sequence was found inside a String literal.
 The Java language specification (section 3.10.6) says an octal
 escape sequence inside a literal String shall consist of a backslash
 followed by:
 
-   OctalDigit | OctalDigit OctalDigit | ZeroToThree OctalDigit OctalDigit
+    OctalDigit | OctalDigit OctalDigit | ZeroToThree OctalDigit OctalDigit
 
 Any octal escape sequence followed by non-octal digits can be confusing,
 e.g. "\038" is interpreted as the octal escape sequence "\03" followed by
@@ -198,11 +198,11 @@ public void foo() {
     </rule>
 
     <rule name="CallSuperInConstructor"
-       language="java"
-         since="3.0"
+          language="java"
+          since="3.0"
           message="It is a good practice to call super() in a constructor"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#CallSuperInConstructor">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#callsuperinconstructor">
       <description>
 It is a good practice to call super() in a constructor. If super() is not called but
 another constructor (such as an overloaded constructor) is called, this rule will not report it.
@@ -238,11 +238,11 @@ public class Foo extends Bar{
     </rule>
 
     <rule name="UnnecessaryParentheses"
-       language="java"
-         since="3.1"
+          language="java"
+          since="3.1"
           message="This statement may have some unnecessary parentheses"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#UnnecessaryParentheses">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#unnecessaryparentheses">
       <description>
 Sometimes expressions are wrapped in unnecessary parentheses, making them look like function calls.
       </description>
@@ -265,18 +265,18 @@ Sometimes expressions are wrapped in unnecessary parentheses, making them look l
 public class Foo {
    boolean bar() {
       return (true);
-      }
+   }
 }
   ]]>
       </example>
     </rule>
 
     <rule name="DefaultPackage"
-       language="java"
-        since="3.4"
-        message="Use explicit scoping instead of the default package private level"
-        class="net.sourceforge.pmd.lang.rule.XPathRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#DefaultPackage">
+          language="java"
+          since="3.4"
+          message="Use explicit scoping instead of the default package private level"
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#defaultpackage">
         <description>
 Use explicit scoping instead of accidental usage of default package private level.
 The rule allows methods and fields annotated with Guava's @VisibleForTesting.
@@ -300,11 +300,11 @@ or MethodDeclaration[@PackagePrivate='true']
 
     <rule name="DataflowAnomalyAnalysis"
           since="3.9"
-              message="Found ''{0}''-anomaly for variable ''{1}'' (lines ''{2}''-''{3}'')."
-              class="net.sourceforge.pmd.lang.java.rule.controversial.DataflowAnomalyAnalysisRule"
-              dfa="true"
-              externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#DataflowAnomalyAnalysis">
-          <description>The dataflow analysis tracks local definitions, undefinitions and references to variables on different paths on the data flow.
+          message="Found ''{0}''-anomaly for variable ''{1}'' (lines ''{2}''-''{3}'')."
+          class="net.sourceforge.pmd.lang.java.rule.controversial.DataflowAnomalyAnalysisRule"
+          dfa="true"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#dataflowanomalyanalysis">
+      <description>The dataflow analysis tracks local definitions, undefinitions and references to variables on different paths on the data flow.
 From those informations there can be found various problems.
 
 1. UR - Anomaly: There is a reference to a variable that was not defined before. This is a bug and leads to an error.
@@ -324,16 +324,14 @@ public void foo() {
           </example>
         </rule>
 
-  <rule 	name="AvoidFinalLocalVariable"
-       language="java"
-        since="4.1"
+    <rule name="AvoidFinalLocalVariable"
+          language="java"
+          since="4.1"
           class="net.sourceforge.pmd.lang.rule.XPathRule"
           message="Avoid using final local variables, turn them into fields"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AvoidFinalLocalVariable">
-          <description><![CDATA[
-Avoid using final local variables, turn them into fields.
-         ]]></description>
-            <priority>3</priority>
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#avoidfinallocalvariable">
+          <description>Avoid using final local variables, turn them into fields.</description>
+          <priority>3</priority>
           <properties>
               <property name="xpath">
                   <value><![CDATA[
@@ -359,27 +357,24 @@ public class MyClass {
        ]]></example>
     </rule>
 
-  <rule
-        name="AvoidUsingShortType"
-       language="java"
-        since="4.1"
-        message="Do not use the short type"
-        class="net.sourceforge.pmd.lang.rule.XPathRule"
-      externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AvoidUsingShortType">
+    <rule name="AvoidUsingShortType"
+          language="java"
+          since="4.1"
+          message="Do not use the short type"
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#avoidusingshorttype">
         <description>
-            <![CDATA[
 Java uses the 'short' type to reduce memory usage, not to optimize calculation. In fact, the JVM does not have any
 arithmetic capabilities for the short type: the JVM must convert the short into an int, do the proper calculation
 and convert the int back to a short. Thus any storage gains found through use of the 'short' type may be offset by
 adverse impacts on performance.
-            ]]>
         </description>
         <priority>1</priority>
         <properties>
             <property name="xpath">
                 <value>
                     <![CDATA[
-            //PrimitiveType[@Image = 'short'][name(../..) != 'CastExpression']
+//PrimitiveType[@Image = 'short'][name(../..) != 'CastExpression']
                     ]]>
                 </value>
             </property>
@@ -398,29 +393,23 @@ public class UsingShort {
      </example>
    </rule>
 
-  <rule
-        name="AvoidUsingVolatile"
-       language="java"
-        since="4.1"
-        class="net.sourceforge.pmd.lang.rule.XPathRule"
-        message="Use of modifier volatile is not recommended."
-      externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AvoidUsingVolatile">
-
+    <rule name="AvoidUsingVolatile"
+          language="java"
+          since="4.1"
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          message="Use of modifier volatile is not recommended."
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#avoidusingvolatile">
         <description>
-            <![CDATA[
 Use of the keyword 'volatile' is generally used to fine tune a Java application, and therefore, requires
 a good expertise of the Java Memory Model. Moreover, its range of action is somewhat misknown. Therefore,
 the volatile keyword should not be used for maintenance purpose and portability.
-            ]]>
         </description>
         <priority>2</priority>
         <properties>
             <property name="xpath">
                 <value>
                     <![CDATA[
-                        //FieldDeclaration[
-                                contains(@Volatile,'true')
-                        ]
+//FieldDeclaration[contains(@Volatile,'true')]
                     ]]>
                 </value>
             </property>
@@ -428,33 +417,30 @@ the volatile keyword should not be used for maintenance purpose and portability.
     <example>
       <![CDATA[
 public class ThrDeux {
-  private volatile String var1;	// not suggested
-  private          String var2;	// preferred
+  private volatile String var1; // not suggested
+  private          String var2; // preferred
 }
       ]]>
     </example>
   </rule>
 
 
-  <rule
-    name="AvoidUsingNativeCode"
-       language="java"
-      since="4.1"
-        message="The use of native code is not recommended."
-        class="net.sourceforge.pmd.lang.rule.XPathRule"
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AvoidUsingNativeCode">
+    <rule name="AvoidUsingNativeCode"
+          language="java"
+          since="4.1"
+          message="The use of native code is not recommended."
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#avoidusingnativecode">
         <description>
-            <![CDATA[
 Unnecessary reliance on Java Native Interface (JNI) calls directly reduces application portability
 and increases the maintenance burden.
-            ]]>
         </description>
         <priority>2</priority>
         <properties>
             <property name="xpath">
                 <value>
                     <![CDATA[
-                        //Name[starts-with(@Image,'System.loadLibrary')]
+//Name[starts-with(@Image,'System.loadLibrary')]
                     ]]>
                 </value>
             </property>
@@ -469,7 +455,7 @@ public class SomeJNIClass {
 
      static {
          System.loadLibrary("nativelib");
-         }
+     }
 
      public void invalidCallsInMethod() throws SecurityException, NoSuchMethodException {
          System.loadLibrary("nativelib");
@@ -479,13 +465,12 @@ public class SomeJNIClass {
         </example>
     </rule>
 
-  <rule
-    name="AvoidAccessibilityAlteration"
-       language="java"
-      since="4.1"
-        message="You should modify visibility of class or methods using getDeclaredConstructors(), getDeclaredConstructor(Class[]), setAccessible() or PrivilegedAction."
-        class="net.sourceforge.pmd.lang.rule.XPathRule"
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AvoidAccessibilityAlteration">
+    <rule name="AvoidAccessibilityAlteration"
+          language="java"
+          since="4.1"
+          message="You should modify visibility of class or methods using getDeclaredConstructors(), getDeclaredConstructor(Class[]), setAccessible() or PrivilegedAction."
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#avoidaccessibilityalteration">
         <description>
             <![CDATA[
 Methods such as getDeclaredConstructors(), getDeclaredConstructor(Class[]) and setAccessible(),
@@ -558,19 +543,17 @@ public class Violation {
       </example>
     </rule>
 
-    <rule	name="DoNotCallGarbageCollectionExplicitly"
-       language="java"
+    <rule name="DoNotCallGarbageCollectionExplicitly"
+          language="java"
           since="4.2"
-            message="Do not explicitly trigger a garbage collection."
-            class="net.sourceforge.pmd.lang.rule.XPathRule"
-            externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#DoNotCallGarbageCollectionExplicitly">
+          message="Do not explicitly trigger a garbage collection."
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#donotcallgarbagecollectionexplicitly">
         <description>
-          <![CDATA[
 Calls to System.gc(), Runtime.getRuntime().gc(), and System.runFinalization() are not advised. Code should have the
 same behavior whether the garbage collection is disabled using the option -Xdisableexplicitgc or not.
 Moreover, "modern" jvms do a very good job handling garbage collections. If memory usage issues unrelated to memory
 leaks develop within an application, it should be dealt with JVM options rather than within the code itself.
-      ]]>
         </description>
         <priority>2</priority>
         <properties>
@@ -617,18 +600,15 @@ public class GCCall {
     </example>
   </rule>
 
-  <rule
-        name="OneDeclarationPerLine"
-       language="java"
+  <rule name="OneDeclarationPerLine"
+        language="java"
         since="5.0"
         class="net.sourceforge.pmd.lang.rule.XPathRule"
         message="Use one line for each declaration, it enhances code readability."
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#OneDeclarationPerLine">
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#onedeclarationperline">
         <description>
-            <![CDATA[
 Java allows the use of several variables declaration of the same type on one line. However, it
 can lead to quite messy code. This rule looks for several declarations on the same line.
-            ]]>
         </description>
        <priority>4</priority>
        <properties>
@@ -659,13 +639,12 @@ String name,
         </example>
   </rule>
 
-  <rule
-        name="AvoidPrefixingMethodParameters"
-       language="java"
+  <rule name="AvoidPrefixingMethodParameters"
+        language="java"
         since="5.0"
         class="net.sourceforge.pmd.lang.rule.XPathRule"
         message="Avoid prefixing parameters by in, out or inOut. Uses Javadoc to document this behavior."
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AvoidPrefixingMethodParameters">
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#avoidprefixingmethodparameters">
         <description>
             <![CDATA[
 Prefixing parameters by 'in' or 'out' pollutes the name of the parameters and reduces code readability.
@@ -712,11 +691,12 @@ public class Foo {
         ]]></example>
   </rule>
 
-  <rule  name="AvoidLiteralsInIfCondition"
-      language="java" since="4.2.6"
-      message="Avoid using Literals in Conditional Statements"
-      class="net.sourceforge.pmd.lang.rule.XPathRule"
-      externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#AvoidLiteralsInIfCondition">
+    <rule name="AvoidLiteralsInIfCondition"
+          language="java"
+          since="4.2.6"
+          message="Avoid using Literals in Conditional Statements"
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#avoidliteralsinifcondition">
     <description>
 Avoid using hard-coded literals in conditional statements. By declaring them as static variables
 or private members with descriptive names maintainability is enhanced. By default, the literals "-1" and "0" are ignored.
@@ -762,11 +742,12 @@ public void checkRequests() {
     </example>
   </rule>
 
-  <rule  name="UseObjectForClearerAPI"
-         language="java" since="4.2.6"
-         message="Rather than using a lot of String arguments, consider using a container object for those values."
-         class="net.sourceforge.pmd.lang.rule.XPathRule"
-         externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#UseObjectForClearerAPI">
+    <rule name="UseObjectForClearerAPI"
+          language="java"
+          since="4.2.6"
+          message="Rather than using a lot of String arguments, consider using a container object for those values."
+          class="net.sourceforge.pmd.lang.rule.XPathRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#useobjectforclearerapi">
     <description>
 When you write a public method, you should be thinking in terms of an API. If your method is public, it means other class
 will use it, therefore, you want (or need) to offer a comprehensive and evolutive API. If you pass a lot of information
@@ -790,17 +771,17 @@ your API.
     <example>
 <![CDATA[
 public class MyClass {
-  public void connect(String username,
-    String pssd,
-    String databaseName,
-    String databaseAdress)
-    // Instead of those parameters object
-    // would ensure a cleaner API and permit
-    // to add extra data transparently (no code change):
-    // void connect(UserData data);
+    public void connect(String username,
+        String pssd,
+        String databaseName,
+        String databaseAdress)
+        // Instead of those parameters object
+        // would ensure a cleaner API and permit
+        // to add extra data transparently (no code change):
+        // void connect(UserData data);
     {
 
-  }
+    }
 }
 ]]>
     </example>
@@ -812,7 +793,7 @@ public class MyClass {
          since="4.2.6"
          message="If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation"
          class="net.sourceforge.pmd.lang.rule.XPathRule"
-         externalInfoUrl="${pmd.website.baseurl}/rules/java/controversial.html#UseConcurrentHashMap">
+         externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_controversial.html#useconcurrenthashmap">
     <description>
 Since Java5 brought a new implementation of the Map designed for multi-threaded access, you can
 perform efficient map reads without blocking other threads.
@@ -832,8 +813,8 @@ perform efficient map reads without blocking other threads.
 <![CDATA[
 public class ConcurrentApp {
   public void getMyInstance() {
-    Map map1 = new HashMap(); 	// fine for single-threaded access
-    Map map2 = new ConcurrentHashMap();  // preferred for use with multiple threads
+    Map map1 = new HashMap();           // fine for single-threaded access
+    Map map2 = new ConcurrentHashMap(); // preferred for use with multiple threads
 
     // the following case will be ignored by this rule
     Map map3 = someModule.methodThatReturnMap(); // might be OK, if the returned map is already thread-safe
diff --git a/pmd-java/src/main/resources/rulesets/java/coupling.xml b/pmd-java/src/main/resources/rulesets/java/coupling.xml
index 0d1e3dd0b3..43c9a63a02 100644
--- a/pmd-java/src/main/resources/rulesets/java/coupling.xml
+++ b/pmd-java/src/main/resources/rulesets/java/coupling.xml
@@ -10,10 +10,10 @@ Rules which find instances of high or inappropriate coupling between objects and
   </description>
 
     <rule name="CouplingBetweenObjects"
-    		  since="1.04"
-        message="High amount of different objects as members denotes a high coupling"
-        class="net.sourceforge.pmd.lang.java.rule.coupling.CouplingBetweenObjectsRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/coupling.html#CouplingBetweenObjects">
+          since="1.04"
+          message="High amount of different objects as members denotes a high coupling"
+          class="net.sourceforge.pmd.lang.java.rule.coupling.CouplingBetweenObjectsRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_coupling.html#couplingbetweenobjects">
     <description>
 This rule counts the number of unique attributes, local variables, and return types within an object. 
 A number higher than the specified threshold can indicate a high degree of coupling.
@@ -26,26 +26,26 @@ import org.Bar;
 import org.Bardo;
 
 public class Foo {
-   private Blah var1;
-   private Bar var2;
- 
- 	//followed by many imports of unique objects
-   void ObjectC doWork() {
-     Bardo var55;
-     ObjectA var44;
-     ObjectZ var93;
-     return something;
-   }
+    private Blah var1;
+    private Bar var2;
+
+    //followed by many imports of unique objects
+    void ObjectC doWork() {
+        Bardo var55;
+        ObjectA var44;
+        ObjectZ var93;
+        return something;
+    }
 }
 ]]>
     </example>
   </rule>
 
   <rule name="ExcessiveImports"
-    		  since="1.04"
-     message="A high number of imports can indicate a high degree of coupling within an object."
-     class="net.sourceforge.pmd.lang.java.rule.coupling.ExcessiveImportsRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/coupling.html#ExcessiveImports">
+        since="1.04"
+        message="A high number of imports can indicate a high degree of coupling within an object."
+        class="net.sourceforge.pmd.lang.java.rule.coupling.ExcessiveImportsRule"
+        externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_coupling.html#excessiveimports">
      <description>
 A high number of imports can indicate a high degree of coupling within an object. This rule 
 counts the number of unique imports and reports a violation if the count is above the 
@@ -58,17 +58,17 @@ import blah.blah.Baz;
 import blah.blah.Bif;
 // 18 others from the same package elided
 public class Foo {
- public void doWork() {}
+    public void doWork() {}
 }
       ]]>
   </example>
    </rule>
 
     <rule name="LooseCoupling"
-    		 since="0.7"
+          since="0.7"
           message="Avoid using implementation types like ''{0}''; use the interface instead"
           class="net.sourceforge.pmd.lang.java.rule.coupling.LooseCouplingRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/coupling.html#LooseCoupling">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_coupling.html#loosecoupling">
       <description>
 The use of implementation types as object references limits your ability to use alternate
 implementations in the future as requirements change. Whenever available, referencing objects 
@@ -77,28 +77,28 @@ by their interface types provides much more flexibility.
         <priority>3</priority>
       <example>
 <![CDATA[
-	// sub-optimal approach
-private ArrayList list = new ArrayList();
+// sub-optimal approach
+private ArrayList<SomeType> list = new ArrayList<>();
 
-public HashSet getFoo() {
-	return new HashSet();
+public HashSet<SomeType> getFoo() {
+    return new HashSet<SomeType>();
 }
 
-	// preferred approach
-private List list = new ArrayList();
+// preferred approach
+private List<SomeType> list = new ArrayList<>();
 
-public Set getFoo() {
-	return new HashSet();
+public Set<SomeType> getFoo() {
+    return new HashSet<SomeType>();
 }
 ]]>
       </example>
     </rule>
 
     <rule name="LoosePackageCoupling"
-    		 since="5.0"
+          since="5.0"
           message="Use of ''{0}'' outside of package hierarchy ''{1}'' is not recommended; use recommended classes instead"
           class="net.sourceforge.pmd.lang.java.rule.coupling.LoosePackageCouplingRule"
-          externalInfoUrl="${pmd.website.baseurl}/rules/java/coupling.html#LoosePackageCoupling">
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_coupling.html#loosepackagecoupling">
       <description>
 Avoid using classes from the configured package hierarchy outside of the package hierarchy, 
 except when using one of the configured allowed classes.
@@ -111,26 +111,28 @@ package some.package;
 import some.other.package.subpackage.subsubpackage.DontUseThisClass;
 
 public class Bar {
-   DontUseThisClass boo = new DontUseThisClass();
+    DontUseThisClass boo = new DontUseThisClass();
 }
   ]]>
       </example>
     </rule>
 
    <rule name="LawOfDemeter"
-        language="java"
-        since="5.0"
-        message="Potential violation of Law of Demeter"
-        class="net.sourceforge.pmd.lang.java.rule.coupling.LawOfDemeterRule"
-        externalInfoUrl="${pmd.website.baseurl}/rules/java/coupling.html#LawOfDemeter">
-        
+         language="java"
+         since="5.0"
+         message="Potential violation of Law of Demeter"
+         class="net.sourceforge.pmd.lang.java.rule.coupling.LawOfDemeterRule"
+         externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_coupling.html#lawofdemeter">
         <description>
-The Law of Demeter is a simple rule, that says "only talk to friends". It helps to reduce coupling between classes or objects. 
+The Law of Demeter is a simple rule, that says "only talk to friends". It helps to reduce coupling between classes
+or objects.
+
 See also the references:
-Andrew Hunt, David Thomas, and Ward Cunningham. The Pragmatic Programmer. From Journeyman to Master. Addison-Wesley Longman, Amsterdam, October 1999.;
-K.J. Lieberherr and I.M. Holland. Assuring good style for object-oriented programs. Software, IEEE, 6(5):38–48, 1989.;
-http://www.ccs.neu.edu/home/lieber/LoD.html;
-http://en.wikipedia.org/wiki/Law_of_Demeter
+
+*   Andrew Hunt, David Thomas, and Ward Cunningham. The Pragmatic Programmer. From Journeyman to Master. Addison-Wesley Longman, Amsterdam, October 1999.;
+*   K.J. Lieberherr and I.M. Holland. Assuring good style for object-oriented programs. Software, IEEE, 6(5):38–48, 1989.;
+*   &lt;http://www.ccs.neu.edu/home/lieber/LoD.html>
+*   &lt;http://en.wikipedia.org/wiki/Law_of_Demeter>
         </description>
         <priority>3</priority>
         <example>
@@ -142,14 +144,14 @@ public class Foo {
     public void example(Bar b) {
         // this method call is ok, as b is a parameter of "example"
         C c = b.getC();
-        
+
         // this method call is a violation, as we are using c, which we got from B.
         // We should ask b directly instead, e.g. "b.doItOnC();"
         c.doIt();
-        
+
         // this is also a violation, just expressed differently as a method chain without temporary variables.
         b.getC().doIt();
-        
+
         // a constructor call, not a method call.
         D d = new D();
         // this method call is ok, because we have create the new instance of D locally.
@@ -159,6 +161,5 @@ public class Foo {
 ]]>
         </example>
     </rule>
-    
 
- </ruleset>
\ No newline at end of file
+</ruleset>
\ No newline at end of file
diff --git a/pmd-test/src/main/java/net/sourceforge/pmd/AbstractRuleSetFactoryTest.java b/pmd-test/src/main/java/net/sourceforge/pmd/AbstractRuleSetFactoryTest.java
index d076e07a23..713dcb36d5 100644
--- a/pmd-test/src/main/java/net/sourceforge/pmd/AbstractRuleSetFactoryTest.java
+++ b/pmd-test/src/main/java/net/sourceforge/pmd/AbstractRuleSetFactoryTest.java
@@ -18,12 +18,14 @@ import java.io.InputStreamReader;
 import java.io.UnsupportedEncodingException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 import java.util.Properties;
 import java.util.StringTokenizer;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;
 
+import org.apache.commons.io.FilenameUtils;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.xml.sax.InputSource;
@@ -115,8 +117,11 @@ public abstract class AbstractRuleSetFactoryTest {
                     messages += "Rule " + fileName + "/" + rule.getName() + " is missing 'externalInfoURL' attribute"
                             + PMD.EOL;
                 } else {
-                    String expectedExternalInfoURL = "https?://pmd.(sourceforge.net|github.io)/.+/rules/"
-                            + fileName.replaceAll("rulesets/", "").replaceAll(".xml", "") + ".html#" + rule.getName();
+                    String expectedExternalInfoURL = "https?://pmd.(sourceforge.net|github.io)/.+/pmd_rules_"
+                            + language.getTerseName() + "_"
+                            + FilenameUtils.getBaseName(fileName)
+                            + ".html#"
+                            + rule.getName().toLowerCase(Locale.ROOT);
                     if (rule.getExternalInfoUrl() == null
                             || !rule.getExternalInfoUrl().matches(expectedExternalInfoURL)) {
                         invalidExternalInfoURL++;
diff --git a/pom.xml b/pom.xml
index 897c97de60..244d17afce 100644
--- a/pom.xml
+++ b/pom.xml
@@ -266,7 +266,7 @@ Additionally it includes CPD, the copy-paste-detector. CPD finds duplicated code
 
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <pmd.website.baseurl>http://pmd.sourceforge.net/snapshot/${project.artifactId}</pmd.website.baseurl>
+        <pmd.website.baseurl>http://pmd.sourceforge.net/snapshot</pmd.website.baseurl>
 
         <argLine>-Xmx512m -Dfile.encoding=${project.build.sourceEncoding}</argLine>
 
@@ -873,7 +873,7 @@ Additionally it includes CPD, the copy-paste-detector. CPD finds duplicated code
         <profile>
             <id>pmd-release</id>
             <properties>
-                <pmd.website.baseurl>https://pmd.github.io/pmd-${project.version}/${project.artifactId}</pmd.website.baseurl>
+                <pmd.website.baseurl>https://pmd.github.io/pmd-${project.version}</pmd.website.baseurl>
             </properties>
             <build>
                 <plugins>