Reformatted code to solve a large number of checkstyle reported

errors.

Author: khmarbaise

src/main/java/org/codehaus/plexus/util/AbstractScanner.java

@@ -16,7 +16,6 @@
  * limitations under the License.
  */
 
-
 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
@@ -30,7 +29,7 @@ public abstract class AbstractScanner
     /**
      * Patterns which should be excluded by default, like SCM files
      * <ul>
-     * <li>Misc: &#42;&#42;/&#42;~, &#42;&#42;/#&#42;#, &#42;&#42;/.#&#42;, &#42;&#42;/%&#42;%, &#42;&#42;/._&#42; </li>
+     * <li>Misc: &#42;&#42;/&#42;~, &#42;&#42;/#&#42;#, &#42;&#42;/.#&#42;, &#42;&#42;/%&#42;%, &#42;&#42;/._&#42;</li>
      * <li>CVS: &#42;&#42;/CVS, &#42;&#42;/CVS/&#42;&#42;, &#42;&#42;/.cvsignore</li>
      * <li>RCS: &#42;&#42;/RCS, &#42;&#42;/RCS/&#42;&#42;</li>
      * <li>SCCS: &#42;&#42;/SCCS, &#42;&#42;/SCCS/&#42;&#42;</li>
@@ -44,8 +43,10 @@ public abstract class AbstractScanner
      * <li>Serena Dimension: &#42;&#42;/.metadata, &#42;&#42;/.metadata/&#42;&#42;</li>
      * <li>Mercurial: &#42;&#42;/.hg, &#42;&#42;/.hg/&#42;&#42;, &#42;&#42;/.hgignore</li>
      * <li>GIT: &#42;&#42;/.git, &#42;&#42;/.gitignore, &#42;&#42;/.gitattributes, &#42;&#42;/.git/&#42;&#42;</li>
-     * <li>Bitkeeper: &#42;&#42;/BitKeeper, &#42;&#42;/BitKeeper/&#42;&#42;, &#42;&#42;/ChangeSet, &#42;&#42;/ChangeSet/&#42;&#42;</li>
-     * <li>Darcs: &#42;&#42;/_darcs, &#42;&#42;/_darcs/&#42;&#42;, &#42;&#42;/.darcsrepo, &#42;&#42;/.darcsrepo/&#42;&#42;&#42;&#42;/-darcs-backup&#42;, &#42;&#42;/.darcs-temp-mail
+     * <li>Bitkeeper: &#42;&#42;/BitKeeper, &#42;&#42;/BitKeeper/&#42;&#42;, &#42;&#42;/ChangeSet,
+     * &#42;&#42;/ChangeSet/&#42;&#42;</li>
+     * <li>Darcs: &#42;&#42;/_darcs, &#42;&#42;/_darcs/&#42;&#42;, &#42;&#42;/.darcsrepo,
+     * &#42;&#42;/.darcsrepo/&#42;&#42;&#42;&#42;/-darcs-backup&#42;, &#42;&#42;/.darcs-temp-mail
      * </ul>
      *
      * @see #addDefaultExcludes()
@@ -75,10 +76,10 @@ public abstract class AbstractScanner
         // Arch
         "**/.arch-ids", "**/.arch-ids/**",
 
-        //Bazaar
+        // Bazaar
         "**/.bzr", "**/.bzr/**",
 
-        //SurroundSCM
+        // SurroundSCM
         "**/.MySCMServerInfo",
 
         // Mac
@@ -114,58 +115,45 @@ public abstract class AbstractScanner
     private MatchPatterns excludesPatterns;
 
     /**
-     * Whether or not the file system should be treated as a case sensitive
-     * one.
+     * Whether or not the file system should be treated as a case sensitive one.
      */
     protected boolean isCaseSensitive = true;
 
     /**
      * Sets whether or not the file system should be regarded as case sensitive.
      *
-     * @param isCaseSensitive whether or not the file system should be
-     *                        regarded as a case sensitive one
+     * @param isCaseSensitive whether or not the file system should be regarded as a case sensitive one
      */
     public void setCaseSensitive( boolean isCaseSensitive )
     {
         this.isCaseSensitive = isCaseSensitive;
     }
 
     /**
-     * Tests whether or not a given path matches the start of a given
-     * pattern up to the first "**".
+     * Tests whether or not a given path matches the start of a given pattern up to the first "**".
      * <p/>
-     * This is not a general purpose test and should only be used if you
-     * can live with false positives. For example, <code>pattern=**\a</code>
-     * and <code>str=b</code> will yield <code>true</code>.
+     * This is not a general purpose test and should only be used if you can live with false positives. For example,
+     * <code>pattern=**\a</code> and <code>str=b</code> will yield <code>true</code>.
      *
-     * @param pattern The pattern to match against. Must not be
-     *                <code>null</code>.
-     * @param str     The path to match, as a String. Must not be
-     *                <code>null</code>.
-     * @return whether or not a given path matches the start of a given
-     *         pattern up to the first "**".
+     * @param pattern The pattern to match against. Must not be <code>null</code>.
+     * @param str The path to match, as a String. Must not be <code>null</code>.
+     * @return whether or not a given path matches the start of a given pattern up to the first "**".
      */
     protected static boolean matchPatternStart( String pattern, String str )
     {
         return SelectorUtils.matchPatternStart( pattern, str );
     }
 
     /**
-     * Tests whether or not a given path matches the start of a given
-     * pattern up to the first "**".
+     * Tests whether or not a given path matches the start of a given pattern up to the first "**".
      * <p/>
-     * This is not a general purpose test and should only be used if you
-     * can live with false positives. For example, <code>pattern=**\a</code>
-     * and <code>str=b</code> will yield <code>true</code>.
+     * This is not a general purpose test and should only be used if you can live with false positives. For example,
+     * <code>pattern=**\a</code> and <code>str=b</code> will yield <code>true</code>.
      *
-     * @param pattern         The pattern to match against. Must not be
-     *                        <code>null</code>.
-     * @param str             The path to match, as a String. Must not be
-     *                        <code>null</code>.
-     * @param isCaseSensitive Whether or not matching should be performed
-     *                        case sensitively.
-     * @return whether or not a given path matches the start of a given
-     *         pattern up to the first "**".
+     * @param pattern The pattern to match against. Must not be <code>null</code>.
+     * @param str The path to match, as a String. Must not be <code>null</code>.
+     * @param isCaseSensitive Whether or not matching should be performed case sensitively.
+     * @return whether or not a given path matches the start of a given pattern up to the first "**".
      */
     protected static boolean matchPatternStart( String pattern, String str, boolean isCaseSensitive )
     {
@@ -175,12 +163,9 @@ protected static boolean matchPatternStart( String pattern, String str, boolean
     /**
      * Tests whether or not a given path matches a given pattern.
      *
-     * @param pattern The pattern to match against. Must not be
-     *                <code>null</code>.
-     * @param str     The path to match, as a String. Must not be
-     *                <code>null</code>.
-     * @return <code>true</code> if the pattern matches against the string,
-     *         or <code>false</code> otherwise.
+     * @param pattern The pattern to match against. Must not be <code>null</code>.
+     * @param str The path to match, as a String. Must not be <code>null</code>.
+     * @return <code>true</code> if the pattern matches against the string, or <code>false</code> otherwise.
      */
     protected static boolean matchPath( String pattern, String str )
     {
@@ -190,71 +175,53 @@ protected static boolean matchPath( String pattern, String str )
     /**
      * Tests whether or not a given path matches a given pattern.
      *
-     * @param pattern         The pattern to match against. Must not be
-     *                        <code>null</code>.
-     * @param str             The path to match, as a String. Must not be
-     *                        <code>null</code>.
-     * @param isCaseSensitive Whether or not matching should be performed
-     *                        case sensitively.
-     * @return <code>true</code> if the pattern matches against the string,
-     *         or <code>false</code> otherwise.
+     * @param pattern The pattern to match against. Must not be <code>null</code>.
+     * @param str The path to match, as a String. Must not be <code>null</code>.
+     * @param isCaseSensitive Whether or not matching should be performed case sensitively.
+     * @return <code>true</code> if the pattern matches against the string, or <code>false</code> otherwise.
      */
     protected static boolean matchPath( String pattern, String str, boolean isCaseSensitive )
     {
         return SelectorUtils.matchPath( pattern, str, isCaseSensitive );
     }
 
     /**
-     * Tests whether or not a string matches against a pattern.
-     * The pattern may contain two special characters:<br>
+     * Tests whether or not a string matches against a pattern. The pattern may contain two special characters:<br>
      * '*' means zero or more characters<br>
      * '?' means one and only one character
      *
-     * @param pattern The pattern to match against.
-     *                Must not be <code>null</code>.
-     * @param str     The string which must be matched against the pattern.
-     *                Must not be <code>null</code>.
-     * @return <code>true</code> if the string matches against the pattern,
-     *         or <code>false</code> otherwise.
+     * @param pattern The pattern to match against. Must not be <code>null</code>.
+     * @param str The string which must be matched against the pattern. Must not be <code>null</code>.
+     * @return <code>true</code> if the string matches against the pattern, or <code>false</code> otherwise.
      */
     public static boolean match( String pattern, String str )
     {
         return SelectorUtils.match( pattern, str );
     }
 
     /**
-     * Tests whether or not a string matches against a pattern.
-     * The pattern may contain two special characters:<br>
+     * Tests whether or not a string matches against a pattern. The pattern may contain two special characters:<br>
      * '*' means zero or more characters<br>
      * '?' means one and only one character
      *
-     * @param pattern         The pattern to match against.
-     *                        Must not be <code>null</code>.
-     * @param str             The string which must be matched against the pattern.
-     *                        Must not be <code>null</code>.
-     * @param isCaseSensitive Whether or not matching should be performed
-     *                        case sensitively.
-     * @return <code>true</code> if the string matches against the pattern,
-     *         or <code>false</code> otherwise.
+     * @param pattern The pattern to match against. Must not be <code>null</code>.
+     * @param str The string which must be matched against the pattern. Must not be <code>null</code>.
+     * @param isCaseSensitive Whether or not matching should be performed case sensitively.
+     * @return <code>true</code> if the string matches against the pattern, or <code>false</code> otherwise.
      */
     protected static boolean match( String pattern, String str, boolean isCaseSensitive )
     {
         return SelectorUtils.match( pattern, str, isCaseSensitive );
     }
 
-
     /**
-     * Sets the list of include patterns to use. All '/' and '\' characters
-     * are replaced by <code>File.separatorChar</code>, so the separator used
-     * need not match <code>File.separatorChar</code>.
+     * Sets the list of include patterns to use. All '/' and '\' characters are replaced by
+     * <code>File.separatorChar</code>, so the separator used need not match <code>File.separatorChar</code>.
      * <p/>
      * When a pattern ends with a '/' or '\', "**" is appended.
      *
-     * @param includes A list of include patterns.
-     *                 May be <code>null</code>, indicating that all files
-     *                 should be included. If a non-<code>null</code>
-     *                 list is given, all elements must be
-     *                 non-<code>null</code>.
+     * @param includes A list of include patterns. May be <code>null</code>, indicating that all files should be
+     *            included. If a non-<code>null</code> list is given, all elements must be non-<code>null</code>.
      */
     public void setIncludes( String[] includes )
     {
@@ -272,21 +239,18 @@ public void setIncludes( String[] includes )
                     list.add( normalizePattern( include ) );
                 }
             }
-            this.includes = list.toArray( new String[ list.size() ] );
+            this.includes = list.toArray( new String[list.size()] );
         }
     }
 
     /**
-     * Sets the list of exclude patterns to use. All '/' and '\' characters
-     * are replaced by <code>File.separatorChar</code>, so the separator used
-     * need not match <code>File.separatorChar</code>.
+     * Sets the list of exclude patterns to use. All '/' and '\' characters are replaced by
+     * <code>File.separatorChar</code>, so the separator used need not match <code>File.separatorChar</code>.
      * <p/>
      * When a pattern ends with a '/' or '\', "**" is appended.
      *
-     * @param excludes A list of exclude patterns.
-     *                 May be <code>null</code>, indicating that no files
-     *                 should be excluded. If a non-<code>null</code> list is
-     *                 given, all elements must be non-<code>null</code>.
+     * @param excludes A list of exclude patterns. May be <code>null</code>, indicating that no files should be
+     *            excluded. If a non-<code>null</code> list is given, all elements must be non-<code>null</code>.
      */
     public void setExcludes( String[] excludes )
     {
@@ -304,7 +268,7 @@ public void setExcludes( String[] excludes )
                     list.add( normalizePattern( exclude ) );
                 }
             }
-            this.excludes = list.toArray( new String[ list.size() ] );
+            this.excludes = list.toArray( new String[list.size()] );
         }
     }
 
@@ -343,12 +307,11 @@ private String normalizePattern( String pattern )
     }
 
     /**
-     * Tests whether or not a name matches against at least one include
-     * pattern.
+     * Tests whether or not a name matches against at least one include pattern.
      *
      * @param name The name to match. Must not be <code>null</code>.
-     * @return <code>true</code> when the name matches against at least one
-     *         include pattern, or <code>false</code> otherwise.
+     * @return <code>true</code> when the name matches against at least one include pattern, or <code>false</code>
+     *         otherwise.
      */
     protected boolean isIncluded( String name )
     {
@@ -361,25 +324,23 @@ protected boolean isIncluded( String name, String[] tokenizedName )
     }
 
     /**
-     * Tests whether or not a name matches the start of at least one include
-     * pattern.
+     * Tests whether or not a name matches the start of at least one include pattern.
      *
      * @param name The name to match. Must not be <code>null</code>.
-     * @return <code>true</code> when the name matches against the start of at
-     *         least one include pattern, or <code>false</code> otherwise.
+     * @return <code>true</code> when the name matches against the start of at least one include pattern, or
+     *         <code>false</code> otherwise.
      */
     protected boolean couldHoldIncluded( String name )
     {
-        return includesPatterns.matchesPatternStart(name, isCaseSensitive);
+        return includesPatterns.matchesPatternStart( name, isCaseSensitive );
     }
 
     /**
-     * Tests whether or not a name matches against at least one exclude
-     * pattern.
+     * Tests whether or not a name matches against at least one exclude pattern.
      *
      * @param name The name to match. Must not be <code>null</code>.
-     * @return <code>true</code> when the name matches against at least one
-     *         exclude pattern, or <code>false</code> otherwise.
+     * @return <code>true</code> when the name matches against at least one exclude pattern, or <code>false</code>
+     *         otherwise.
      */
     protected boolean isExcluded( String name )
     {