For the sake of demonstration, we will use the following Groovy script, which on purposely violates several coding rules that CodeNarc inspects:

import java.io.*;

public class DirListing {

  public static void main(String[] args) throws IOException {
    String path;
    if (args.length > 0) {
      path = args[0];
    } else {
      path = ".";
    }
    File directory = new File(path);
    File[] files = directory.listFiles();
    System.out.println("Directory of "
      + directory.getCanonicalFile().getAbsolutePath());
    for (int i = 0; i < files.length; i++) {
      if (files[i].isFile()) {
        File file = files[i];
        System.out.println(file.getName());
      }
    }
  }

}

In fact, the previous code is actually plain Java, but since Groovy almost fully supports Java syntax, the code will run under Groovy as well.

The task that is performed by the script is a simple directory file listing. The program takes a directory path as its first argument. If the argument is omitted, the current directory is used. All first-level file (not directory) names are printed to the standard output.

We assume that the script is placed in the src directory located in your current working folder.

We can launch the CodeNarc command-line interface using Groovy script with a little help from Grape (see the Simplifying dependency management with Grape recipe).

The violations that are reported are easy to fix, and most of them are self-explanatory.

As you probably noticed, we specified only one rule set file (rulesets/unnecessary.xml) as an input parameter to CodeNarc. That specific rule-set groups rules for redundant code and can be omitted or simplified. Writing redundant, non-idiomatic code is exactly what Java programmers will face during their early days of Groovy programming since Groovy accepts Java syntax.

As of writing CodeNarc has 300+ rules split into 21 major group (rule set). Each group has its own name that can be referred to in the form of rulesets/<name>.xml. All those rule files are part of the CodeNarc library, and you don't need to download them separately. More information on the existing rules can be found at http://codenarc.sourceforge.net/codenarc-rule-index.html.

Let's go through a few violations to give the reader a taste of Groovy:

If we just fix all those violations, our Groovy code will look as follows:

import java.io.*

class DirListing {

  static void main(String[] args) throws IOException {
    String path
    if (args.length > 0) {
      path = args[0]
    } else {
      path = '.'
    }
    File directory = new File(path)
    File[] files = directory.listFiles()
    def dirPath = directory.canonicalFile.absolutePath
    System.out.println("Directory of ${dirPath}")
    for (int i = 0; i < files.length; i++) {
      if (files[i].isFile()) {
        File file = files[i]
        System.out.println(file.name)
      }
    }
  }

}

Similarly to spelling or grammar checkers, CodeNarc does not detect all possible styling/coding mistakes. So, there is still room for manual code reviews that may improve your code even more. CodeNarc can be an early indicator for the parts of the code base that need deeper analysis and refactoring.

By using some of the knowledge we've learned in this chapter, as well as the information that we will learn in Chapter 3, Using Groovy Language Features and Chapter 4, Working with Files in Groovy, we can rewrite the original code in a more idiomatic way:

def path = args.size() > 0 ? args[0] : '.'
def directory = new File(path)
def dirPath = directory.canonicalFile.absolutePath
println "Directory of ${dirPath}"
directory.eachFile { File file ->
  if (file.isFile()) {
    println file.name
  }
}

The previous code will produce the same result as our original and modified scripts.