CodeNarc Change Log
-------------------------------------------------------------------------------
http://www.codenarc.org

Changes in version 0.13 (February 2011)
-------------------------------------------
NEW FEATURES
- New and improved syntax for defining custom rulesets. Just list the rule names you want. No need to specify
  ruleset filename or rule class. No more tweaking your custom rulesets with every CodeNarc release when we
  add new rules to the "basic" ruleset or one of the others. Feature #3193684.
- Better support for command line runners. You can now specify the report type "console" as a command line parameter,
  and the CodeNarc text report is output to the console instead of a file. Feature #3162487
- All rules now provide a nicely formatted message. This makes console tools and the CodeNarc Web Console much more
  user friendly. Feature #3162847
- Greatly improved styling of the HTML report. Feature #3192593
- Improved error messages when CodeNarc is mis-configured and configuration file does not compile. Feature #3193468
- Improved println rule. If a class defines a println method, then it is OK to call this method because it won't dispatch to System.out.println. Feature #3194121

NEW RULES
  Dead/Unnecessary Code
- EmptyInstanceInitializer rule (basic) - Feature #3163464 - An empty instance initializer. It is safe to remove it.
- EmptyStaticInitializer rule (basic) - Feature #3161685 - An empty static initializer was found. It is safe to remove it.
- EmptyMethod rule (basic) - Feature #3163806 - A method was found without an implementation. If the method is overriding or implementing a parent method, then mark it with the @Override annotation.
- UnnecessaryCallToSubstring rule (unnecessary) - Feature #3164688 - Calling String.substring(0) always returns the original string. This code is meaningless.
- UnnecessaryModOne rule (unnecessary) - Feature #3164684 - Any expression mod 1 (exp % 1) is guaranteed to always return zero. This code is probably an error, and should be either (exp & 1) or (exp % 2).
- UnnecessarySelfAssignment rule (unnecessary) - Feature #3164674 - Method contains a pointless self-assignment to a variable or property.
- UnnecessaryTransientModifier rule (unnecessary) - Feature #3164672 - The field is marked as transient, but the class isn't Serializable, so marking it as transient has no effect.
- UnnecessaryFail rule (junit) - Feature #3105925 - In a unit test, catching an exception and immediately calling Assert.fail() is pointless and hides the stack trace. It is better to rethrow the exception or not catch the exception at all.
- UnnecessaryPublicModifier rule (unnecessary) - Feature #3166320 - The 'public' modifier is not required on methods or classes.
- UnnecessaryDefInMethodDeclaration rule (unnecessary) - Feature #3165469 - If a method has a visibility modifier, then the def keyword is unneeded. For instance 'def private method() {}' is redundant and can be simplified to 'private method() {}'.
- UnnecessarySemicolon rule (unnecessary) - Feature #3176207 - Semicolons as line terminators are not required in Groovy: remove them. Do not use a semicolon as a replacement for empty braces on for and while loops; this is a confusing practice.
- UnnecessaryGString rule (unnecessary) - Feature #3183521 - String objects should be created with single quotes, and GString objects created with double quotes. Creating normal String objects with double quotes is confusing to readers.

  Bugs/Bad Practices
- AssignmentInConditional rule (basic) - An assignment operator (=) was used in a conditional test. This is usually a typo, and the comparison operator (==) was intended.
- SerializableClassMustDefineSerialVersionUID rule (basic) - Feature #3161076 - Classes that implement Serializable should define a serialVersionUID.
- ConsecutiveStringConcatenation rule (basic) - Feature #3163826 - Catches concatenation of two string literals on the same line. These can safely by joined.
- ConsecutiveLiteralAppends rule (basic) - Feature #3161779 - Violations occur when method calls to append(Object) are chained together with literals as parameters. The chained calls can be joined into one invocation.
- AddEmptyString rule (basic) - Feature #3161763 - Finds empty string literals which are being added. This is an inefficient way to convert any type to a String.
- BrokenOddnessCheck rule (basic) - Feature #3164687 - The code uses x % 2 == 1 to check to see if a value is odd, but this won't work for negative numbers (e.g., (-5) % 2 == -1). If this code is intending to check for oddness, consider using x & 1 == 1, or x % 2 != 0.
- ExceptionExtendsError rule (exceptions) - Feature #3161749 - Errors are system exceptions. Do not extend them.
- MissingNewInThrowStatementRule (exceptions) - Feature #3166115 - Improved existing rule to catch throwing a class literal, which always causes a RuntimeException.
- UseAssertTrueInsteadOfAssertEquals (junit) - Feature #3172959 - This rule was expanded to handle assert statements as well as JUnit style assertions.
- GroovyLangImmutable rule (basic) - Feature #3175158 - The groovy.lang.Immutable annotation has been deprecated and replaced by groovy.transform.Immutable. Do not use the Immutable in groovy.lang.
- IntegerGetInteger rule (basic) - Feature #3174771 - This rule catches usages of java.lang.Integer.getInteger(String, ...) which reads an Integer from the System properties. It is often mistakenly used to attempt to read user input or parse a String into an Integer. It is a poor piece of API to use; replace it with System.properties['prop'].
- BooleanGetBoolean rule (basic) - Feature #3174770 - This rule catches usages of java.lang.Boolean.getBoolean(String) which reads a boolean from the System properties. It is often mistakenly used to attempt to read user input or parse a String into a boolean. It is a poor piece of API to use; replace it with System.properties['prop̈́'].
- ChainedTest rule (junit) - Feature #3175647 - A test methodency that invokes another test method is a chained test; the methods are dependent on one another. Tests should be isolated, and not be dependent on one another.
- CoupledTestCase rule (junit) - Feature #3175645 - This rule finds test cases that are coupled to other test cases, either by invoking static methods on another test case or by creating instances of another test case. If you require shared logic in test cases then extract that logic to a new class where it can properly be reused.

  Concurrency Problems
- BusyWait rule (concurrency) - Feature #3170271 - Busy waiting (forcing a Thread.sleep() while waiting on a condition) should be avoided. Prefer using the gate and barrier objects in the java.util.concurrent package.
- DoubleCheckedLocking rule (concurrency) - Feature #3170263 - This rule detects double checked locking, where a 'lock hint' is tested for null before initializing an object within a synchronized block. Double checked locking does not guarantee correctness and is an anti-pattern.
- InconsistentPropertyLocking rule (concurrency) - Feature #3164700 - Class contains similarly-named get and set methods where one method of the pair is marked either @WithReadLock or @WithWriteLock and the other is not locked at all.
- InconsistentPropertySynchronization rule (concurrency) - Feature #3164699 - Class contains similarly-named get and set methods where the set method is synchronized and the get method is not, or the get method is synchronized and the set method is not.
- StaticCalendarField rule (concurrency) - Feature #3164702 - Calendar objects should not be used as static fields. Calendars are inherently unsafe for multithreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.
- StaticDateFormatField rule (concurrency) - DateFormat objects should not be used as static fields. DateFormat are inherently unsafe for multithreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.
- StaticMatcherField rule (concurrency) - Feature #3170276 - Matcher objects should not be used as static fields. Calendars are inherently unsafe for multithreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.
- SynchronizedOnBoxedPrimitive rule (concurrency) - Feature #3164708 - The code synchronizes on a boxed primitive constant, such as an Integer. Since Integer objects can be cached and shared, this code could be synchronizing on the same object as other, unrelated code, leading to unresponsiveness and possible deadlock
- SynchronizedOnReentrantLock rule (concurrency) - Feature #3170262 - Synchronizing on a ReentrantLock field is almost never the intended usage. A ReentrantLock should be obtained using the lock() method and released in a finally block using the unlock() method.
- SynchronizedOnString rule (concurrency) - Feature #3164707 - Synchronization on a String field can lead to deadlock because Strings are interned by the JVM and can be shared.
- SynchronizedReadObjectMethod rule (concurrency) - Feature #3164704 - Catches Serializable classes that define a synchronized readObject method. By definition, an object created by deserialization is only reachable by one thread, and thus there is no need for readObject() to be synchronized. If the readObject() method itself is causing the object to become visible to another thread, that is an example of very dubious coding style.
- ThreadGroup rule (concurrency) - Feature #3161692 - Avoid using ThreadGroup; although it is intended to be used in a threaded environment it contains methods that are not thread safe.
- VolatileArrayField rule (concurrency) - Feature #3170265 - Volatile array fields are unsafe because the contents of the array are not treated as volatile. Changing the entire array reference is visible to other threads, but changing an array element is not.
- WaitOutsideOfWhileLoop rule (concurrency) - Feature #3127703 - Calls to Object.wait() must be within a while loop. This ensures that the awaited condition has not already been satisfied by another thread before the wait() is invoked. It also ensures that the proper thread was resumed and guards against incorrect notification.

BUG FIXES
- Fix Bug #3162499 UnnecessaryObjectReferences: This rule was not ignoring 'this' references, leading to false positives. 
- Fix Bug #3164150 UnnecessaryReturnKeyword: Rule is no longer triggered if the return is for a closure.
- Fix Bug #3165139 LoggingSwallowsStacktrace: No longer reports multiple logger errors.
- Fix bug #3166311: Error on numeric/boolean property values if they contain leading or trailing whitespace in "codenarc.properties" or in XML ruleset file.
- Fix bug #3170295: @SuppressWarnings does not work with GMetrics-based rules (CC and ABC).
- Fix bug #3190483: The UnusedPrivateField rule now ignores fields named serialVersionUID. The rule has a property called ignoreFieldNames that can be used to add other ignores as well.
- Fix bug #3162975: The UnusedPrivate* rules now correctly read anonymous classes.
- Fix bug #3155974: The UnusedPrivate* rules now correctly read inner classes.
- Fix bug #3183443: Restricted the ConfusingTernary rule to reduce false positives. The rule looks for inverted conditionals in ternary statements. It did not account for Groovy Truth, and suggested 'x != null' be inverted to 'x', but that is not the inverse. So the rule was relaxed. 
- Fix bug #3195027: The violation message for "Replace Getter with Property Access" suggests converting ".getURLs()" to ".uRLs". This has been corrected to ".URLs". 
- Fix bug #3196019: Compiling files with unresolved Grapes dependencies no longer causes an error.

POTENTIAL BREAKING CHANGES
- addViolation(ASTNode) is deprecated. Instead use addViolation(ASTNode, String) when adding violations to the output.

THANKS
 - Many thanks to Mathilde Lemée, Guillaume Laforge, and Tim Yates for helping us redesign our HTML report.
 - Big thanks to Evgeny Goldin and Cédric Champeau for reporting bugs which helps us improve the product so much faster.
 
Changes in version 0.12 (January 2011)
-------------------------------------------
NEW FEATURES
- Improved performance of the CodeNarc Ant Task (by multi-threading source code analysis) - Feature #3150044
- Add support for message parameter substitution in Rule descriptions - Feature #3133988

NEW RULES
- AbstractClassWithoutAbstractMethod rule (design) - Feature #3160204 - Adds a violation when an abstract class does not contain any abstract methods
- CompareToWithoutComparable rule (basic) - Adds violation if you implement a compare method without implementing the Comparable interface
- ExplicitGarbageCollection rule (basic) - Feature #3106689 - Adds a violation if you try to manually trigger a garbage collection run
- CloseWithoutCloseable rule (design) - Feature #3138445 - Adds a violation if you implement a close method without imlpementing the Closeable interface
- FinalClassWithProtectedMember rule (design) - Feature #3137650 - Adds violation if you have a protected member in a final class
- CatchArrayIndexOutOfBoundsException rule (exceptions)  - Feature #3122979 - Adds violation if you explicitly catch ArrayIndexOutOfBoundsException
- CatchIndexOutOfBoundsException rule (exceptions) - Feature #3122979 - Adds violation if you explicitly catch IndexOutOfBoundsException
- ConfusingTernary rule (basic) - Feature #3158945 - Adds violation if you use unnecessary negation within a ternary expression
- ConstantsOnlyInterface rule (design) - Feature #3159134 - Adds violation if an interface contains constants but no methods
- EmptyMethodInAbstractClass rule (design) - Feature #3159180 - Adds violation if an abstract class contains an empty method
- RequiredString rule (generic) - Feature #3122980 - Adds violation if a user-defined String is not found. For example, a copyright notice may be required. 
- UseAssertFalseInsteadOfNegation rule (junit) - Feature #3114728 - Adds violation if JUnit's assertEquals is used with the boolean literal 'false'
- UseAssertTrueInsteadOfNegation rule (junit) - Feature #3114728 - Adds violation if JUnit's assertEquals is used with the boolean literal 'true'
- JUnitTestMethodWithoutAssert. rule (junit) - Feature #3111443 - Adds violation if a JUnit test method contains no assert statements
- LoggerForDifferentClass rule (logging) - Feature #3114736 - Adds violation if a Logger is created based on a Class that is not the enclosing class
- LoggerWithWrongModifiers rule (logging) - Adds violation if a Logger is not private, final, and static. 
- LoggingSwallowsStacktrace rule (logging) - Adds violation if a log statement logs an exception without the accompanying stack trace
- MultipleLoggers rule (logging) - Adds a violation if a class declares more than one logger field
- MissingNewInThrowStatement (exceptions) - Feature #3140762  -Adds a violation if a throw statement is used to throw a class literal
- SimpleDateFormatMissingLocale rule (basic) - Feature #3160227 - Adds a violation if SimpleDateFormat is used without a Locale.
- UnnecessaryBigDecimalInstantiation rule (unnecessary) - Adds a violation for explicit instantiation of BigDecimal
- UnnecessaryBigIntegerInstantiation rule (unnecessary) - Adds a violation for explicit instantiation of BigInteger
- UnnecessaryCatchBlock rule (unnecessary) - Feature #3107168 - Adds violation if catch block does nothing but throw original exception
- UnnecessaryDoubleInstantiation rule (unnecessary) - Adds a violation for explicit instantiation of Double
- UnnecessaryFloatInstantiation rule (unnecessary) - Adds a violation for explicit instantiation of Float
- UnnecessaryInstantiationToGetClass (unnecessary) - Feature #3158935 - Adds a violation if a new instance is created in order to invoke getClass()
- UnnecessaryIntegerInstantiation rule (unnecessary) - Adds a violation for explicit instantiation of Integer
- UnnecessaryLongInstantiation rule (unnecessary) - Adds a violation for explicit instantiation of Long
- UnnecessaryNullCheck Rule (unnecessary) - Feature #3160184 - Adds violation when a null-safe dereference can be used instead of an explicit null check
- UnnecessaryNullCheckBeforeInstanceOf rule (unnecessary) - Feature #3159274 - Adds a violation for an unnecessary null check before using the instanceof operator
- UnnecessaryObjectReferences rule (unnecessary) - Feature #3107838 - Adds a violation for a chain of setters being invoked, which can be converted into a with or identity block
- UnnecessaryCallForLastElement rule (unnecessary) - Feature #3107884 - Adds violation if accessing the last element of a list without using the .last() method or -1th index
- UnnecessaryCollectCall rule (unnecessary) - Feature #3110317 - Adds a violation if a collect method call can be replaced with the spread operator
- UnnecessaryCatchBlock rule  (unnecessary)- Feature #3110318 - Adds a violation if a catch block does nothing but throw the original exception
- UnnecessaryGetter rule  (unnecessary)- Feature #3110321 - Adds a violation if a a getter method is called explicitly instead of using property syntax
- UnusedPrivateMethodParameter rule (unused) - Feature #3151598 - Adds a violation if the parameter to a private method is never used within that method 

BUG FIXES
- Fix Bug #3127967: DuplicateImportRule: Fix for Groovy 1.7. Resort to parsing source code.
- Fix Bug #3146678: UnnecessaryGetter false positive, e.g. def allPaths = resultsMap.keySet()  keySet() can probably be rewritten as set.
- Fix Bug #3111189: "StatelessClassRule - Honor @Immutable".
- Fix Bug #3111181: "UnnecessaryIfStatement - misses if without explicit return".
- Fix Bug #3108126: "assertNoViolations still passes when compile fails"
- Fix Bug #3111439: "Synchronized on getClass() rule gives double warnings".
- Fix Bug #3111438: "Lines with annotations have the wrong source line".
- Fix Bug #3109909: DuplicateStringLiteralRule: Add "" as default ignoreStringLiteral.
- Fix Bug #3110308: "Rules to catch null returns ignore ternary expressions".
- Fix Bug #3110303: "ExplicitCallToXMethod rules should ignore spread statements".
- Fix Bug #3109917: "DuplicateStringLiteralRule - enum names".
- Fix Bug #3109628: "Exceptions are thrown with CodeNarc v0.11" – "GString as map key checking classes that do not exist yet” and “unnecessary ctor rule breaks for anonymous classes".
- Fix Bug #3190754: Don't use default ClassLoader for loading rule scripts.

POTENTIAL BREAKING CHANGES
- Moved the existing StringInstantiation and BooleanInstantiation rules from the Basic ruleset into the Unnecessary ruleset.
  Also renamed the rules to UnnecessaryStringInstantiationRule and UnnecessaryBooleanInstantiation).
  Likewise, the rule classes were moved from the org.codenarc.rule.basic package into org.codenarc.rule.unnecessary.
  NOTE: This should only affect users if
    * You configured one of these rules specifically by rule name or by class name within a custom ruleset
    * You configured one of these rules (by rule name) within "codenarc.properties"
    * You configured one of these rules (by rule name) within a @SuppressWarnings annotation
    * You configured one of these rules (by rule name) within "codenarc-message.properties".
- Removed deprecated applyToFilenames and doNotApplyToFilenames properties of AbstractRule.

OTHER CHANGES
- UnnecessaryIfStatementRule: Expand the rule to also catch if/else statements that contain only single constant/literal expressions for the if and/or else blocks, if the if is not the last statement in the block.
- Feature #3108153: Expand ReturnNull* rules to catch elvis operators
- Feature #3111442: "add better error messages to the ReturnsNull*Rules"
- Feature #3111440: "added better violation messages to BigDecimalInstantiationRule, BooleanInstantiationRule, and StringInstantiationRule".
- Add isValid() to SourceCode (and AbstractSourceCode).


Changes in version 0.11 (November 2010)
-------------------------------------------
NEW FEATURES
- @SuppressWarnings support. All rules now recognize the java.lang.SuppressWarnings annotation on fields, methods, and classes. If this annotation is added then there will be no violations produced. Just as in Java, the annotation requires a String or List<String> parameter. For example, annotating a class with @SuppressWarnings('UnusedPrivateField') will ignore the rule for that class. Annotating a method with @SuppressWarnings(['UnusedPrivateField', 'UnnecessaryIfStatementRule']) will ignore both rules for the annotated method. 
- Better "codenarc create-rule" support. You can create a new rule by running "codenarc create-rule" from the root of the CodeNarc codebase. This script has been updated to properly format Javadoc, prompt for the author name, and update the Maven Site .apt documentation. 

NEW RULES
BooleanMethodReturnsNull Rule (basic) : Checks for a method with Boolean return type that returns an explicit null. 
DeadCode Rule (basic) :  Checks for dead code that appears after a return statement or after an exception is thrown. 
DoubleNegative Rule (basic) :  Checks for using a double negative, which is always positive. 
DuplicateCaseStatement Rule (basic) :  Check for duplicate case statements in a switch block, such as two equal integers or strings. 
ExplicitCallToAndMethod Rule (basic) :  This rule detects when the and(Object) method is called directly in code instead of using the & operator. 
ExplicitCallToCompareToMethod Rule (basic) :  This rule detects when the compareTo(Object) method is called directly in code instead of using the <=>, >, >=, <, and <= operators. 
ExplicitCallToDivMethod Rule (basic) :  This rule detects when the div(Object) method is called directly in code instead of using the / operator.
ExplicitCallToEqualsMethod Rule (basic) :  This rule detects when the equals(Object) method is called directly in code instead of using the == or != operator. 
ExplicitCallToGetAtMethod Rule (basic) :  This rule detects when the getAt(Object) method is called directly in code instead of using the [] index operator. 
ExplicitCallToLeftShiftMethod Rule (basic) :  This rule detects when the leftShift(Object) method is called directly in code instead of using the \<\< operator. 
ExplicitCallToMinusMethod Rule (basic) :  This rule detects when the minus(Object) method is called directly in code instead of using the - operator. 
ExplicitCallToMultiplyMethod Rule (basic) :  This rule detects when the multiply(Object) method is called directly in code instead of using the * operator. 
ExplicitCallToModMethod Rule (basic) :  This rule detects when the mod(Object) method is called directly in code instead of using the % operator. 
ExplicitCallToOrMethod Rule (basic) :  This rule detects when the or(Object) method is called directly in code instead of using the | operator. 
ExplicitCallToPlusMethod Rule (basic) :  This rule detects when the plus(Object) method is called directly in code instead of using the + operator. 
ExplicitCallToPowerMethod Rule (basic) :  This rule detects when the power(Object) method is called directly in code instead of using the ** operator. 
ExplicitCallToRightShiftMethod Rule (basic) :  This rule detects when the rightShift(Object) method is called directly in code instead of using the \>\> operator. 
ExplicitCallToXorMethod Rule (basic) :  This rule detects when the xor(Object) method is called directly in code instead of using the ^ operator. 
ExplicitArrayListInstantiation Rule (basic) :  This rule checks for the explicit instantiation of an ArrayList. In Groovy, it is best to write new ArrayList() as [], which creates the same object.
ExplicitHashMapInstantiation Rule (basic) :  This rule checks for the explicit instantiation of a HashMap. In Groovy, it is best to write new HashMap() as [:], which creates the same object.
ExplicitHashSetInstantiation Rule (basic) :  This rule checks for the explicit instantiation of a HashSet. In Groovy, it is best to write new HashSet() as [] as Set, which creates the same object.
ExplicitLinkedListInstantiation Rule (basic) :  This rule checks for the explicit instantiation of a LinkedList. In Groovy, it is best to write new LinkedList() as [] as Queue, which creates the same object.
ExplicitStackInstantiation Rule (basic) :  This rule checks for the explicit instantiation of a Stack. In Groovy, it is best to write new Stack() as [] as Stack, which creates the same object.
ExplicitTreeSetInstantiation Rule (basic) :  This rule checks for the explicit instantiation of a TreeSet. In Groovy, it is best to write new TreeSet()>> as [] as SortedSet, which creates the same object. 
GStringAsMapKey Rule  A GString should not be used as a map key since its hashcode is not guaranteed to be stable. 
InvertedIfElse Rule (basic) :  An inverted if-else statement is one in which there is a single if statement with a single else branch and the boolean test of the if is negated. 
RemoveAllOnSelf Rule (basic) : Don't use removeAll to clear a collection. 
ReturnsNullInsteadOfEmptyArray Rule (basic) : If you have a method or closure that returns an array, then when there are no results return a zero-length (empty) array rather than null. 
ReturnsNullInsteadOfEmptyCollection Rule (basic) : If you have a method or closure that returns a collection, then when there are no results return a zero-length (empty) collection rather than null. 
SerialVersionUID Rule (basic) : A serialVersionUID is normally intended to be used with Serialization. It needs to be of type long, static, and final. 
UnnecessaryConstructor Rule (unnecessary) : This rule detects when a constructor is not necessary; i.e., when there's only one constructor, it's public, has an empty body, and takes no arguments.
UnnecessaryCollectionCall Rule (unnecessary) : Checks for useless calls to collections.
UnnecessaryOverridingMethod Rule (unnecessary) : Checks for an overriding method that merely calls the same method defined in a superclass.
UnnecessaryReturnKeyword Rule (unnecessary) :  In Groovy, the return keyword is often optional.
SynchronizedOnGetClass Rule (concurrency) : Checks for synchronization on getClass() rather than class literal. 
UseOfNotifyMethod Rule (concurrency) : Checks for code that calls notify() rather than notifyAll(). 
DuplicateNumberLiteral Rule (dry) : This rule checks for duplicate number literals within the current class. 
DuplicateStringLiteral Rule (dry) : This rule checks for duplicate String literals within the current class.
CatchIllegalMonitorStateException Rule (exceptions) : Dubious catching of IllegalMonitorStateException. 
ConfusingClassNamedException Rule (exceptions) : This class is not derived from another exception, but ends with 'Exception'. 
ReturnNullFromCatchBlock Rule (exceptions) : Returning null from a catch block often masks errors and requires the client to handle error codes. 
UseAssertEqualsInsteadOfAssertTrue Rule (junit) : This rule detects JUnit assertions in object equality. 
UseAssertTrueInsteadOfAssertEqualsRule Rule (junit) : This rule detects JUnit calling assertEquals where the first parameter is a boolean. 
UseAssertNullInsteadOfAssertEquals Rule (junit) : This rule detects JUnit calling assertEquals where the first or second parameter is null. 
UseAssertSameInsteadOfAssertTrue Rule (junit) : This rule detects JUnit calling assertTrue or assertFalse where the first or second parameter is an Object#is() call testing for reference equality. 
JUnitFailWithoutMessage Rule (junit) : This rule detects JUnit calling the fail() method without an argument. 
JUnitStyleAssertions Rule (junit) : This rule detects calling JUnit style assertions like assertEquals, assertTrue, assertFalse, assertNull, assertNotNull.
ConfusingMethodName Rule (naming) : Checks for very confusing method names. The referenced methods have names that differ only by capitalization.
ObjectOverrideMisspelledMethodName Rule (naming) : Verifies that the names of the most commonly overridden methods of Object: equals, hashCode and toString, are correct.
MethodCount Rule (size) : Checks if the number of methods within a class exceeds the number of lines specified by the maxMethod property.

BUG FIXES
- None reported, none fixed! 

POTENTIAL BREAKING CHANGES
- AbstractAstVisitor - If you implemented your own rule by subclassing AbstractAstVisitor then your code might break. It is a compile error and the breakage will be clear and obvious. In order to support @SuppressWarnings, we needed to change AbstractAstVisitor. The method visitMethodNode became visitMethodNodeEx, visitClass became visitClassEx, visitConstructorOrMethod became visitConstructorOrMethodEx, visitField became visitFieldEx, visitProperty became visitPropertyEx, and visitConstructor became visitConstructorEx. From within these new methods there is no need to call super.visitX. In the rare case that the simple renaming does not fix your problem then please contact the mailing list.
- The following three classes were moved from the org.codenarc.rule.basic package into org.codenarc.rule.unnecessary.
  Likewise, the associated rules were moved from the "basic" ruleset into the new "unnecessary" ruleset.
  You will need to adjust your ruleset configuration if you included one of these rules specifically in a custom ruleset, or configured them as part of the "basic" ruleset. 
    * UnnecessaryBooleanExpressionRule
    * UnnecessaryIfStatementRule
    * UnnecessaryTernaryExpressionRule

OTHER CHANGES
- CodeNarc now requires Groovy 1.7 to run. Keep in mind that it can still run against (analyze) older Groovy code.
- There is a new rule set (category) called "dry", meaning "do not repeat yourself".
- There is a new "unnecessary" rule set (category).
- AstUtil enhancements - For writers of rules: there are new utility methods in the AstUtil class. See the javadoc for more details.

Changes in version 0.10 (26 September 2010)
-------------------------------------------
BUG FIXES
- Fix Bug #3071531: "Unused rules don't recognized method closures". https://sourceforge.net/tracker/?func=detail&atid=1126573&aid=3071531&group_id=250145. e.g. private def bar() { }  .. return this.&bar;
- Fix: UnusedPrivateField: Don't produce violation if field is a Closure field and is executed.
- Fix: ImportFromSamePackage: Fix for (ignore) alias imports within same package.   package org.xyz;  import org.xyz.MyBigClass as MBC.
NEW RULES
- New UnnecessaryIfStatementRule (basic):  Checks for if statements where the if and else blocks are only returning true and false constants. if(x) { return true } else { return false }.
- New UnnecessaryBooleanExpressionRule (basic): Check for unnecessary boolean expressions, including ANDing (&&) or ORing (||) with true, false, null, or Map/List/String/Number literal. Also checks for negation of true, false, null, or Map/List/String/Number literal.
- New BigDecimalInstantiationRule (basic): Avoid creating BigDecimal with a decimal (float/double) literal. Use a String literal. From PMD. See http://pmd.sourceforge.net/rules/basic.html#AvoidDecimalLiteralsInBigDecimalConstructor. Note that println new BigDecimal(0.1) prints out 0.1000000000000000055511151231257827021181583404541015625.
- UnusedObjectRule (unused): Checks for object allocations that are not assigned or used, unless it is the last statement within a block (because it may be the intentional return value).
- New UnusedArrayRule (unused): This inspection reports any instances of Groovy array allocation where the array allocated is ignored. Such allocation expressions are legal Groovy, but are usually either inadvertent, or evidence of a very odd object initialization strategy. (IntelliJ). When an ExpressionStatement has as its expression an ArrayExpression.
- Implement ImplementationAsTypeRule (design): Checks that particular classes are never used as types in variable declarations, return values or parameters. GregorianCalendar, HashMap, HashSet, Hashtable, LinkedList, LinkedHashMap, LinkedHashSet, TreeSet, TreeMap, Vector, ArrayList, CopyOnWriteArrayList, CopyOnWriteArraySet, ConcurrentHashMap, ArrayBlockingQueue, ConcurrentLinkedQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, PriorityQueue, SynchronousQueue (see Checkstyle). (design)
- New JUnitUnnecessaryTearDownRule (junit). Checks for tearDown() methods that only call super.tearDown().
- New JUnitUnnecessarySetUpRule (junit). Checks for setUp() methods that only call super.setUp().
NEW REPORT WRITER
- New InlineXmlReportWriter (from Robin Bramley) for improved integration with the Hudson Violations plugin. See http://wiki.hudson-ci.org/display/HUDSON/Violations.   
OTHER CHANGES
- CodeNarc now requires Groovy 1.6 to run. Keep in mind that it can still run against (analyze) older Groovy code.
- Upgrade to GMetrics 0.3 for AbcComplexityRule and CyclomaticComplexityRule. Violations now include line number and source line.
- All JUnit rules (JUnit*Rule): Also apply to classes with names ending in *TestCase.
- Add codenarc create-rule script to create a new rule and associated classes/tests. https://sourceforge.net/tracker/?func=detail&aid=3005873&group_id=250145&atid=1126575. (Hamlet D'Arcy)
- ConstantTernaryExpressionRule: Also flag constant Map and List expressions.
- ConstantIfExpressionRule: Also flag constant Map and List expressions.
- GrailsPublicControllerMethod: add ignoreMethodNames property.
- Add reference to Sonar plugin. http://docs.codehaus.org/display/SONAR/Groovy+Plugin to web site.
- Add reference to Hudson Violations Plugin. http://wiki.hudson-ci.org/display/HUDSON/Violations to web site.


Changes in version 0.9 (10 May 2010)
------------------------------------
BUG FIXES
- Fix bug #2985592: "MissingPropertyException: No such property: W3C_XML_SCHEMA_NS_URI".
- XML RuleSet: Allow wildcards (*) in <include> and <exclude>.
- WildcardPattern: Escape plus sign ('+').
- NestedBlockDepthRule: Ignore first level of closure for Closure Fields (since they are really equivalent to methods).
NEW SIZE/COMPLEXITY RULES
- AbcComplexityRule - Check ABC size/complexity score against threshold for method and class average (size)
- CyclomaticComplexityRule - Check Cyclomatic Complexity against threshold for method and class average (size)
NEW CONCURRENCY RULES
- NestedSynchronizationRule (concurrency - Hamlet D�Arcy)
- RunFinalizersOnExitRule (concurrency - Hamlet D�Arcy)
- SynchronizedMethodRule (concurrency - Hamlet D�Arcy) 
- SynchronizedOnThisRule (concurrency - Hamlet D�Arcy)
- ThreadLocalNotStaticFinalRule (concurrency - Hamlet D�Arcy)
- ThreadYieldRule: (concurrency - Hamlet D�Arcy)
- VolatileLongOrDoubleFieldRule: (concurrency - Hamlet D�Arcy)
NEW BASIC RULES
- CloneableWithoutCloneRule (basic - Hamlet D'Arcy & Ren� Gr�schke)
- ConstantIfExpressionRule: if(true) or if(false). Or literal constant. (basic)
- ConstantTernaryExpressionRule: true ? x : y or false, null or literal.(basic)
- UnnecessaryTernaryExpressionRule: x ? true : false. Or Boolean.TRUE. Or where both expressions are the same. (basic)
OTHER CHANGES
- Deprecate GrailsSessionReferenceRule. Default enabled to false. Note in online docs.
- StatelessClassRule: Add setAddToIgnoreFieldNames() method (adds to ignoreFieldNames).
- Add new <rule>.description.html property for each rule. Change the HtmlReportWriter to look for *.description.html first; if not defined, use *.description. Continue to use *.description in XML report. Potential BREAKAGE: If you have overridden the "<rule>.description" message for a predefined rule in a "codenarc-messages.properties" file, you will have to change those message keys to "<rule>.description.html".
- Do not include disabled rules in list of rules at bottom of HTML/XML report.
- HtmlReportWriter: Don�t log warning if "codenarc-messages.properties" contains *.description but not *.description.html.
- UnusedVariableRule: Fix limitation: Does not recognize variable references on the same line as the variable declaration.
- GroovyDslRuleSet: Throw MissingPropertyException if a non-existent property is set within a Groovy RuleSet DSL.
- CodeNarcRunner: Add System.out println of summary counts.
- MethodSizeRule: Apply to constructors as well.
- WildcardPattern: Trim pattern values. This includes property values such as common rule properties applyToFileNames/doNotApplyToFileNames, applyToClassNames/doNotApplyToClassNames. Or many rule-specific properties such as ignoreMethodNames for the MethodSizeRule.
- PropertiesFileRuleSetConfigurer: Log warning if rule name not found.
- TESTS: AbstractRuleTestCase: Add assertViolations(String source, Map[] violationMaps) helper method.
- TESTS: Fix tests broken on Linux.


Changes in version 0.8.1 (2 Feb 2010)
------------------------------------
BUG FIXES
- Fix Bug #2943025: "NestedBlockDepthRule: Produces erroneous results on Groovy 1.6.x." https://sourceforge.net/tracker/?func=detail&aid=2943025&group_id=250145&atid=1126573
- Fix Bug #2943028: "PackageNameRule may show incorrect violations for classes within the default package when running in Groovy 1.6.x." https://sourceforge.net/tracker/?func=detail&aid=2943028&group_id=250145&atid=1126573
- Fix Bug #2935587 "Building CodeNarc 0.8 fails." - Problem from Joern Huxhorn (Jan 18, 2010) � Unable to build from the downloaded CodeNarc-0.8-bin.tar.gz.  http://sourceforge.net/tracker/?func=detail&aid=2935587&group_id=250145&atid=1126573. See CodeNarc - Unable to Build From TarGZip.doc. Remove platform/locale dependencies: AbstractReportWriterTest, UrlResourceTest, GrailsSessionReferenceRuleTest, GrailsPublicControllerMethodRuleTest, GrailsServletContextReferenceRuleTest, GrailsStatelessServiceRuleTest. [Jan 24]
- Fix StackOverflow in Groovy 1.7.0 for some rules: All rules that implement the visitVariableExpression(VariableExpression expression) visitor method: UnusedVariableRule, UnusedPrivateFieldRule, GrailsSessionReferenceRule, GrailsServletContextReferenceRule � Removed call to super.visitVariableExpression(expression) since that seems to cause problems (StackOverflow) in Groovy 1.7.0.
- Fix tests broken when running in Groovy 1.6 or Groovy 1.7.
- DuplicateImportRule: Document that this rule does not work when running under Groovy 1.7 (i.e., will not produce any violations), and does not distinguish between multiple duplicate imports for the same class.


Changes in version 0.8 (17 Jan 2010)
------------------------------------
BUG FIXES
- Fix Bug #2930886: "Cannot load rules when groovy is in different classloader".  XmlReaderRuleSet, ReportWriterFactory: Replace calls to Class.forName() with getClass().classLoader.loadClass(). https://sourceforge.net/tracker/?func=detail&atid=1126573&aid=2930886&group_id=250145.
- Fix Bug #2847520: "UnusedVariableRule: Closure variable must be invoked". UnusedVariableRule: Referencing an (explicit) Closure variable without invoking it is not recognized as a valid reference. e.g., final CLOSURE = { .. }; return CLOSURE. https://sourceforge.net/tracker/?func=detail&aid=2847520&group_id=250145&atid=1126573
- Fix false positive: Local closures: If a closure is assigned to a local variable, then used later in the method, CodeNarc report the variable unused. [I think this has already been resolved, perhaps as part of Bug #2847520]. (reported by Donal Murtagh)
- Fix false positive: Default arguments: If a constant is only used as the value of a default argument, CodeNarc reports this constant unused. (reported by Donal Murtagh)
REPORTS
- Create XmlReportWriter for wrting out an XML report ("xml"). (beta)
- Create TextReportWriter. Writes out text report with violations by file and priority and summary counts.
- Enable configuring all provided ReportWriters (HtmlReportWriter, XmlReportWriter, TextReportWriter) to write to the stdout (console).
- Enable specifying the full class name of a custom ReportWriter class.
- CodeNarcTask: Add support for <option> nested elements under the <report> element.
- HtmlReportWriter: Externalize strings to resource bundle.
- Remove setTitle() and setOutputFile() from ReportWriter interface.
- ReportWriter: Rename writeOutReport() method to writeReport().
- Create AbstractReportWriter.
RULES
- Create new NestedBlockDepthRule. Checks for nesting of all types of block statements (and closures), including for, if, while, try and switch statements. (design)
- MethodSizeRule: Add support for "ignoreMethodNames" property to enable filtering.
- AbstractRule: Enhance applyToFileNames to handle optional path (e.g. "abc/def/MyClass.groovy").
- AbstractRule: The (previously deprecated) applyToFilenames and doNotApplyToFilenames properties now throw an UnsupportedOperationException.
- AbstractRule: Add optional description property; Use it in report if specified.
OTHER CHANGES
- Allow spaces within comma-separated list of ruleset files. Applies when specifying ruleset files for the CodeNarc Ant Task or the CodeNarc script.
- CodeNarcRunner: Don�t require that reportWriters is non-empty.
- AntFileSetSourceAnalyzer: Specify sourceDirectories relative to project base directory.
- Reorganize web site. Add Reports section. Add pages for HTML, XML and and text reports.
- Add support and documentation for running CodeNarc as part of an automated test suite (e.g. JUnit).
- Add List getSourceDirectories() to SourceAnalyzer interface and implementation classes.
- Change "codenarc-version.txt" to contain only the version number.
- Rename AbstractTest to AbstractTestCase.


Changes in version 0.7 (25 Aug 2009)
------------------------------------
BUG FIXES
- Fix Bug #2825698: "UnusedVariableRule: stops after 1st unused variable per name". https://sourceforge.net/tracker/?func=detail&aid=2825698&group_id=250145&atid=1126573.
- Fix Bug #2828696: "UnusedImport rule with fully qualified class reference"   https://sourceforge.net/tracker/?func=detail&atid=1126573&aid=2828696&group_id=250145.
- UnusedImportRule: Add support for static imports. Document known limitation: will not work on imports with wildcards.
- UnnecessaryGroovyImportRule: Add java.net as another automatically included package.
NEW FEATURES AND INFRASTRUCTURE
- Groovy DSL for defining RuleSets. (GroovyDslRuleSet and RuleSetBuilder).
- Enable optional prefix of "file:", "http:" or any other standard URL prefix for resource files, including ruleset files, "codenarc.properties" and rule scripts.
    * Addresses Tracker Issue #2828616: "Allow ruleset file to be specified as a file or url" https://sourceforge.net/tracker/?func=detail&atid=1126575&aid=2828616&group_id=250145.
- CodeNarcTask and AntFileSetSourceAnalyzer: Allow more than one FileSet to be added.
    * Addresses Tracker Issue #2831255: "Ant task should accept any ResourceCollection for source"  https://sourceforge.net/tracker/?func=detail&aid=2831255&group_id=250145&atid=1126575.
- HtmlReportWriter: Show rule name in color according to priority.
- CompositeRuleSet: Rename add(RuleSet) to addRuleSet(RuleSet). Add addRule(Rule).
RULES
- Create new PropertyNameRule. (naming)
- FieldNameRule: Do not apply to property fields.


Changes in version 0.6 (17 Jul 2009)
------------------------------------
BUG FIXES
- Fix BUG #2798845 : "StringIndexOutOfBoundsException" https://sourceforge.net/tracker/?func=detail&atid=1126573&aid=2798845&group_id=250145
- Fix BUG #2799752: GrailsPublicControllerMethodRule - should only apply itself to methods within classes that have suffix "Controller". (see email from Jason Anderson, May 26, 2009) https://sourceforge.net/tracker/?func=detail&aid=2799752&group_id=250145&atid=1126573
- Fix BUG #2796953: StatelessClassRule requires applyToFileNames or applyToFilesMatching.  https://sourceforge.net/tracker/?func=detail&atid=1126573&aid=2796953&group_id=250145
- Fix BUG #2811213: "FieldNameRule: Names for final fields - not be all caps". FieldNameRule: Field names for final instance fields should not default to be all caps like static final fields. For instance: final List sentEmails = []. Rather, "If a property is declared final the private field is created final and no setter is generated." (http://groovy.codehaus.org/Groovy+Beans). So, they should be named with "normal" naming conventions. Re-purpose the finalRegex property to just apply to final instance fields and default to null so that final field names use same convention as non-final. https://sourceforge.net/tracker/?func=detail&aid=2811213&group_id=250145&atid=1126573.
- Fix: GrailsStatelessServiceRule: Should only apply to *Service classes.
RULES
- Implement UnusedVariableRule. (unused)
- Implement UnusedPrivateMethodRule. (unused)
- Implement UnusedPrivateFieldRule. (unused).
- MethodNameRule: Add support for ignoreMethodNames.
- ParameterNameRule: Add support for ignoreParameterNames.
- VariableNameRule: Add support for ignoreVariableNames.
- FieldNameRule: Add support for ignoreFieldNames.
- IllegalRegexRule: Include line numbers in rule violations.
INFRASTRUCTURE
- Allow setting custom name and path for "codenarc.properties" file using "codenarc.properties.file" system property.
- WildcardPattern: Add optional defaultMatches constructor parameter to specify return value of matches() when the pattern string is null or empty.
- HtmlReportWriter: Show rules with priority 4. This enables configuring rules to be included in the report but not fail the build.
- SourceCode: Add int getLineNumberForCharacterIndex(int charIndex).
- CodeNarcRunner: Don�t mandate that reportWriters is non-empty.
OTHER
- Publish CodeNarc to Maven repository.


Changes in version 0.5 (24 May 2009)
------------------------------------
BUG FIXES
- FIX: IllegalRegexRule: Don�t stop after first violation.
- FIX: VariableNameRule processing enums: "ArrayIndexOutOfBoundsException: Negative array index [-3] too large for array size 1".
- FIX: BooleanInstantiationRule, VariableNameRule: Error parsing code with Enums.
- FIX: Rules sometimes produce two violations for a single line. (e.g. EmptyElseBlockRule, PrintlnRule)
POTENTIAL BREAKING CHANGES
- Normalize all path separators (/,\) in SourceCode paths.
- SourceCodeCriteria: Change applyToFilenames and doNotApplyToFilenames to applyToFileNames and doNotApplyToFileNames.
- DirectorySourceAnalyzer: Change applyToFilenames and doNotApplyToFilenames to applyToFileNames and doNotApplyToFileNames.
RULES
- Created new "grails" RuleSet and nine new Rules:
   * GrailsStatelessServiceRule (Specially-configured StatelessClassRule) (grails)
   * GrailsPublicControllerMethodRule (grails)
   * GrailsServletContextReferenceRule (grails)
   * GrailsSessionReferenceRule (grails)
   * StatelessClassRule (generic)
   * EmptySynchronizedStatementRule (basic).
   * EmptySwitchStatementRule (basic).
   * EqualsAndHashCodeRule (basic)
   * JUnitPublicNonTestMethodRule (junit).
- Change JUnit rules to use applyToClassNames=*Test,*Tests.
- ClassSizeRule: Don�t include package name in violation message.
INFRASTRUCTURE
- Support running CodeNarc as a command-line application (org.codenarc.CodeNarc).
- Add support for Groovy rule scripts.
- AbstractAstVisitorRule: Add applyToClassNames and doNotApplyToClassNames. Filter rules based on class and/or package.
- AbstractRule. Add applyToFileNames and doNotApplyToFileNames (deprecate applyToFilenames and doNotApplyToFilenames).
- Normalize all separators (/,\) in SourceCode paths to '/'.
- AbstractRule: Enable setting violationMessage to empty string to turn it off.
- HtmlReportWriter: Log output report filename.
- Include number (index) of rule in Rule Descriptions section of HTML report.
- Create CodeNarcRunner class; refactor CodeNarc and CodeNarcTask to use it.
- HtmlReportWriter: Shrink font size of the rule descriptions at the end of the HTML report.
- HtmlReportWriter: Remove "Source Directories" section.
- Create FilesystemSourceAnalyzer.
- Refactor WildcardPattern to (optionally) support comma-separated list of patterns.
- Change WildcardPattern to support Ant-style �**� wildcards.
- Refactor AbstractRule and AbstractAstVisitor add/create Violation and source line helper methods.
- Add createViolation(SourceCode, ASTNode) method to AbstractRule.
- Add line(int) method to SourceCode to return trimmed source line.
- Add createViolation() convenience method(s) to AbstractRule.
- AbstractAstVisitor: Replace isAlreadyVisited() and registerAsVisited() with isFirstVisit().
DEPRECATIONS
- AbstractRule: Deprecated applyToFilenames and doNotApplyToFilenames (replace with applyToFileNames and doNotApplyToFileNames).
- Deprecated DirectorySourceAnalyzer.
DOCUMENTATION
- Create "Create Rule" document.
- Add section in "Configuring Rules" on Turning Off a Rule.


Changes in version 0.4 (31 Mar 2009)
------------------------------------
INFRASTRUCTURE
- Support for wildcards (*,?) in RuleSet <include> and <exclude>, and in Rule.applyToFilenames.
- Fix for configuration from properties files - allow setting superclass fields.
- Add better logging, including stacktrace, when an error occurs during processing.
- Format (and truncate) source line within the HtmlReportWriter.
- Improve violation information for imports - line number and actual source line.
- Make version at the bottom of the HTML report a link to the web site.
- Refactor SourceCodeUtil to a SourceCodeCriteria class.
- CodeNarcTask: Log elapsed time after analysis is complete.
- CodeNarcTask: Don�t fail build until after reports are generated.
- Create WildcardPattern class.
- Create AstUtil. Move isBlock() and isEmptyBlock() from AbstractAstVisitor.
RULES
- Created new "junit" and "logging" RuleSets and a bunch of new Rules:
   * JUnitAssertAlwaysSuccedsRule (junit)
   * JUnitAssertAlwaysFailsRule (junit)
   * JUnitTearDownCallsSuperRule (junit)
   * JUnitSetUpCallsSuperRule (junit)
   * SystemErrPrintRule. (logging)
   * SystemOutPrintRule. (logging)
   * PrintlnRule. (logging)
   * PrintStackTraceRule. (logging)
   * CatchNullPointerExceptionRule. (exceptions)
   * CatchExceptionRule. (exceptions)
   * CatchRuntimeExceptionRule. (exceptions)
   * CatchErrorRule. (exceptions)
   * ThrowThrowableRule (exceptions)
   * ThrowExceptionRule (exceptions)
   * ThrowNullPointerExceptionRule (exceptions)
   * ThrowRuntimeExceptionRule (exceptions)
   * ThrowErrorRule (exceptions)
- BooleanInstantiationRule: Also check for Boolean.valueOf(true/false).
DOCUMENTATION
- Add example reports for open source Groovy projects: Grails, Griffon and Gradle.


Changes in version 0.3 (02 Mar 2009)
------------------------------------
INFRASTRUCTURE
- Read rules configuration from optional "codenarc.properties" file. (PropertiesRuleSetConfigurer).
- CodeNarcTask: Add support for maxPriority3Violations property, etc.
- AbstractRule: Add applyToFilenames and doNotApplyToFilenames - available to all rules (subclasses).
- HtmlReportWriter: Display sourceLine and message on separate lines with named bullets.
RULES
- Created new "naming" RuleSets and new Rules:
   * AbstractClassNameRule. (naming)
   * ClassNameRule. (naming)
   * FieldNameRule. (naming)
   * InterfaceNameRule. (naming)
   * MethodNameRule. (naming)
   * PackageNameRule. (naming)
   * ParameterNameRule. (naming)
   * VariableNameRule. (naming)
MINOR FIXES/ENHANCEMENTS
- Fix NullPointerException for compiler errors from import rules.
- AbstractRule: Introduce violationMessage property. Overrides default message if set.
- Rename Violation description property to message.
- Rename HtmlReportWriter CSS file to 'codenarc-htmlreport.css'.
- Change SourceCodeUtil.shouldApplyTo() to take a Map of criteria.
- Add setName() and setPriority() to AbstractRule.
DOCUMENTATION
- Add info to online docs re: standard rule properties.
- Reorganize docs � separate doc for each RuleSet; section for each rule; table for properties.
- Update RuleSets doc with info about configuring using properties file.
- Create "Configuring Rules" document (adapt existing "custom-rule-descriptions.apt").


Changes in version 0.2 (07 Feb 2009)
------------------------------------
- Create XML Schema Definition (XSD) for XML RuleSet file.
    * NOTE: RuleSet files MUST declare this schema
    * NOTE: RuleSet files are validated against this schema
- More powerful and flexible RuleSet definition, including:
    * Nested RuleSets
    * Use <include> and <exclude> to filter rules from nested RuleSets
    * Use <rule-config> to configure rules from nested RuleSets

- Created new "generic", "braces", and "size" RuleSets
- Created new Rules:
   * IllegalRegexRule. (generic)
   * RequiredRegexRule. (generic)
   * ElseBlockBracesRule. (braces)
   * ForStatementBracesRule. (braces)
   * IfStatementBracesRule. (braces)
   * WhileStatementBracesRule. (braces)
   * MethodSizeRule. (size)
   * ClassSizeRule. (size)

- Rule: Rename "id" property to "name".
    * NOTE: This is a potential breakage if you have defined custom Rules.
- Flexible customization and localization of rule descriptions. ("codenarc-messages.properties")
- HtmlReportWriter: Add setTitle(), setOutputFile() to ReportWriter interface.


Changes in version 0.1 (24 Jan 2009)
------------------------------------
- Initial release. Includes 16 Rules; HtmlReportWriter; CodeNarcAntTask, DirectorySourceAnalyzer; XML RuleSets, etc..


