Commit 326093f8 authored by E19C506H's avatar E19C506H
Browse files

noPackage

parent d21816e8
<?xml version="1.0" encoding="ASCII"?>
<java:Model xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:java="http://www.eclipse.org/MoDisco/Java/0.2.incubation/java" name="Test">
<ownedElements name="(default package)">
<ownedElements xsi:type="java:ClassDeclaration" originalCompilationUnit="//@compilationUnits.0" name="Foo">
<modifier visibility="public"/>
</ownedElements>
</ownedElements>
<ownedElements name="myPackage">
<ownedElements xsi:type="java:ClassDeclaration" originalCompilationUnit="//@compilationUnits.1" name="ClassWithPackage">
<modifier visibility="public"/>
</ownedElements>
</ownedElements>
<orphanTypes xsi:type="java:PrimitiveTypeInt" name="int"/>
<orphanTypes xsi:type="java:PrimitiveTypeLong" name="long"/>
<orphanTypes xsi:type="java:PrimitiveTypeFloat" name="float"/>
<orphanTypes xsi:type="java:PrimitiveTypeDouble" name="double"/>
<orphanTypes xsi:type="java:PrimitiveTypeBoolean" name="boolean"/>
<orphanTypes xsi:type="java:PrimitiveTypeVoid" name="void"/>
<orphanTypes xsi:type="java:PrimitiveTypeChar" name="char"/>
<orphanTypes xsi:type="java:PrimitiveTypeShort" name="short"/>
<orphanTypes xsi:type="java:PrimitiveTypeByte" name="byte"/>
<compilationUnits name="Foo.java" originalFilePath="D:\workSpace\Test\src\Foo.java" types="//@ownedElements.0/@ownedElements.0"/>
<compilationUnits name="ClassWithPackage.java" originalFilePath="D:\workSpace\Test\src\myPackage\ClassWithPackage.java" package="//@ownedElements.1" types="//@ownedElements.1/@ownedElements.0"/>
</java:Model>
......@@ -28,19 +28,15 @@ rule Java2SMM {
)
}
helper def: allMeasures(project : java!Model): Set(smm!Measure) =
Set{
-- Example rule
helper def: allMeasures(project: java!Model): Set(smm!Measure) =
Set{-- Example rule
--
thisModule.numberOfClasses(),
-- Multithreading rules
--
thisModule.dontCallThreadRun(),
thisModule.avoidThreadGroup(),
thisModule.useNotifyAllInsteadOfNotify(),
-- Code Style rules
--
thisModule.shortMethodName(),
......@@ -51,6 +47,7 @@ helper def: allMeasures(project : java!Model): Set(smm!Measure) =
thisModule.unnecessaryReturn(),
thisModule.longVariable(),
thisModule.noPackageDeclaration(),
-- Design rules
--
thisModule.tooManyFields(),
......@@ -58,12 +55,11 @@ helper def: allMeasures(project : java!Model): Set(smm!Measure) =
thisModule.returnFromFinallyBlock(),
thisModule.longInstantiation(),
thisModule.shortInstantiation(),
thisModule.returnEmptyArrayRatherThanNull(),
--thisModule.returnEmptyArrayRatherThanNull(),
thisModule.excessiveParameterList(),
thisModule.finalFieldCouldBeStatic(),
thisModule.signatureDeclareThrowsException(),
thisModule.avoidThrowingNullPointerException(),
-- Performance rules
--
thisModule.uselessStringValueOf(),
......@@ -74,13 +70,10 @@ helper def: allMeasures(project : java!Model): Set(smm!Measure) =
thisModule.emptyStatementBlock(),
thisModule.avoidRethrowingException(),
thisModule.integerInstantiation(),
-- Documentation rules
--
thisModule.commentContent(),
thisModule.commentRequired(),
-- Error prone rules
--
thisModule.missingBreakInSwitch(),
......@@ -92,17 +85,15 @@ helper def: allMeasures(project : java!Model): Set(smm!Measure) =
thisModule.emptyTryBlock(),
thisModule.emptyWhileStmt(),
thisModule.dontImportSun(),
thisModule.finalizeShouldBeProtected(),
--thisModule.finalizeShouldBeProtected(),
-- Best practices rules
thisModule.avoidThrowingNewInstanceOfSameException(),
thisModule.switchDensity(),
thisModule.avoidStringBufferField()
};
thisModule.switchDensity() --thisModule.avoidStringBufferField()
};
-- creates a new Measure when String.valueOf is called to append its argument to a string
rule MeasureUselessStringValueOf(method : java!MethodInvocation) {
rule MeasureUselessStringValueOf(method: java!MethodInvocation) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -110,10 +101,12 @@ rule MeasureUselessStringValueOf(method : java!MethodInvocation) {
),
noc: smm!DimensionalMeasure (
name <- 'Useless string value of',
shortDescription <- 'No need to call String.valueOf to append to a string; just use the valueOf() argument directly.'
shortDescription <- 'No need to call String.valueOf to append to a string;'
+ ' just use the valueOf() argument directly.'
),
measurement: smm!DirectMeasurement (
error<- 'The class '+ method.originalCompilationUnit.name + ' violates the rule useless string value of.'
error <- 'The class ' + method.originalCompilationUnit.name + ' violates the'
+ ' rule useless string value of.'
)
do {
noc;
......@@ -121,9 +114,8 @@ rule MeasureUselessStringValueOf(method : java!MethodInvocation) {
}
------------------------------------------------------------------------------------------
-- A Measure instance if the class violates the rule 'AvoidDollarSigns'.
rule MesureAvoidDollarSigns(node : java!ASTNode) {
rule MesureAvoidDollarSigns(node: java!ASTNode) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -131,7 +123,8 @@ rule MesureAvoidDollarSigns(node : java!ASTNode) {
),
noc: smm!DimensionalMeasure (
name <- 'AvoidDollarSigns',
shortDescription <- 'Avoid using dollar signs in variable/method/class/interface names.'
shortDescription <- 'Avoid using dollar signs in'
+ ' variable/method/class/interface names.'
),
measurement: smm!DirectMeasurement (
error <- node.name + ' has dollar in ' + node.originalCompilationUnit.name
......@@ -141,10 +134,8 @@ rule MesureAvoidDollarSigns(node : java!ASTNode) {
}
}
-- A Measure instance if the class violates the rule 'ShortMethodName'.
rule MesureShortMethodName(method : java!MethodDeclaration) {
rule MesureShortMethodName(method: java!MethodDeclaration) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -152,19 +143,20 @@ rule MesureShortMethodName(method : java!MethodDeclaration) {
),
noc: smm!DimensionalMeasure (
name <- 'ShortMethodName',
shortDescription <- 'Method names names that are very short are not helpful to the reader.'
shortDescription <- 'Method names names that are very short are not helpful'
+ ' to the reader.'
),
measurement: smm!DirectMeasurement (
error <- method.name + ' is too short in ' + method.originalCompilationUnit.name
error <- method.name + ' is too short in ' + method.originalCompilationUnit.
name
)
do {
noc;
}
}
-- A Measure instance if the class violates the rule 'ShortClassName'.
rule MesureShortClassName(class : java!ClassDeclaration) {
rule MesureShortClassName(class: java!ClassDeclaration) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -172,7 +164,8 @@ rule MesureShortClassName(class : java!ClassDeclaration) {
),
noc: smm!DimensionalMeasure (
name <- 'ShortClassName',
shortDescription <- 'Short Classnames with fewer than e.g. five characters are not recommended.'
shortDescription <- 'Short Classnames with fewer than e.g. five characters'
+ ' are not recommended.'
),
measurement: smm!DirectMeasurement (
error <- 'The Class ' + class.name + ' is too short.'
......@@ -182,9 +175,8 @@ rule MesureShortClassName(class : java!ClassDeclaration) {
}
}
-- creates a new Measure when Thread.run() is used instead of Thread.start()
rule MeasureDontCallThreadRun(method : java!MethodInvocation) {
rule MeasureDontCallThreadRun(method: java!MethodInvocation) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -192,19 +184,21 @@ rule MeasureDontCallThreadRun(method : java!MethodInvocation) {
),
noc: smm!DimensionalMeasure (
name <- 'Don t call Thread.run()',
shortDescription <- 'Explicitly calling Thread.run() method will execute in the caller s thread of control. Instead, call Thread.start() for the intended behavior.'
shortDescription <- 'Explicitly calling Thread.run() method will execute in'
+ ' the caller s thread of control. Instead, call Thread.start() for'
+ ' the intended behavior.'
),
measurement: smm!DirectMeasurement (
error<-'The class '+ method.originalCompilationUnit.name + ' violates the rule don t call Thread.run().'
error <- 'The class ' + method.originalCompilationUnit.name + ' violates the'
+ ' rule don t call Thread.run().'
)
do {
noc;
}
}
-- A Measure instance if the class violates the rule 'TooManyFields'.
rule MesureTooManyFields(class : java!ClassDeclaration) {
rule MesureTooManyFields(class: java!ClassDeclaration) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -212,7 +206,8 @@ rule MesureTooManyFields(class : java!ClassDeclaration) {
),
noc: smm!DimensionalMeasure (
name <- 'TooManyFields',
shortDescription <- 'Classes that have too many fields can become unwieldy and could be redesigned to have fewer field.'
shortDescription <- 'Classes that have too many fields can become unwieldy'
+ ' and could be redesigned to have fewer field.'
),
measurement: smm!DirectMeasurement (
error <- class.originalCompilationUnit.name + ' have too many fields'
......@@ -222,9 +217,9 @@ rule MesureTooManyFields(class : java!ClassDeclaration) {
}
}
-- creates a new Measure when the parameter of String.indexOf(char) is not of type char when checking for the index of a single character
rule MeasureUseIndexOfChar(method : java!MethodInvocation) {
-- creates a new Measure when the parameter of String.indexOf(char) is not of type char
-- when checking for the index of a single character
rule MeasureUseIndexOfChar(method: java!MethodInvocation) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -232,10 +227,12 @@ rule MeasureUseIndexOfChar(method : java!MethodInvocation) {
),
noc: smm!DimensionalMeasure (
name <- 'Use index of char',
shortDescription <- 'Use String.indexOf(char) when checking for the index of a single character; it executes faster.'
shortDescription <- 'Use String.indexOf(char) when checking for the index of'
+ ' a single character; it executes faster.'
),
measurement: smm!DirectMeasurement (
error<- 'The class '+ method.originalCompilationUnit.name + ' violates the rule index of char.'
error <- 'The class ' + method.originalCompilationUnit.name + ' violates the'
+ ' rule index of char.'
)
do {
noc;
......@@ -243,7 +240,6 @@ rule MeasureUseIndexOfChar(method : java!MethodInvocation) {
}
------------------------------------------------------------------------------------------
rule numberOfClasses() {
to
om: smm!ObservedMeasure (
......@@ -254,7 +250,8 @@ rule numberOfClasses() {
name <- 'Number of Classes'
),
measurement: smm!DirectMeasurement (
value <- java!ClassDeclaration.allInstances() -> reject(each | each.isProxy()) -> size()
value <- java!ClassDeclaration.allInstances() -> reject(each | each.
isProxy()) -> size()
)
do {
......@@ -262,8 +259,8 @@ rule numberOfClasses() {
}
}
-- Rule that creates an instance of Measure for the switch statement with too few branches passed in parameter
-- Rule that creates an instance of Measure for the switch statement with too few
-- branches passed in parameter
rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatement) {
to
om: smm!ObservedMeasure (
......@@ -272,10 +269,15 @@ rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatem
),
tooFewBranchesForASwitchStatement: smm!DimensionalMeasure (
name <- 'TooFewBranchesForASwitchStatement',
shortDescription <- 'Switch statements are intended to be used to support complex branching behaviour. Using a switch for only a few cases is ill-advised, since switches are not as easy to understand as if-then statements. In these cases use the if-then statement to increase code readability.'
shortDescription <- 'Switch statements are intended to be used to support'
+ ' complex branching behaviour. Using a switch for only a few cases'
+ ' is ill-advised, since switches are not as easy to understand as'
+ ' if-then statements. In these cases use the if-then statement to'
+ ' increase code readability.'
),
measurement: smm!DirectMeasurement (
error <- 'Too few branches for SwitchStatement in Class : ' + switchStatement.originalCompilationUnit.name,
error <- 'Too few branches for SwitchStatement in Class : ' + switchStatement.
originalCompilationUnit.name,
value <- thisModule.nbBranchesOfASwitchStatement(switchStatement)
)
do {
......@@ -283,9 +285,10 @@ rule MeasureTooFewBranchesForASwitchStatement(switchStatement: java!SwitchStatem
}
}
--------------------------------------------- ShortInstantiation ---------------------------------------------
--------------------------------------------- ShortInstantiation
--- ---------------------------------------------
-- A Measure instance if the class violates the rule 'ShortInstantiation'.
rule MeasureShortInstantiation(variable : java!CompilationUnit) {
rule MeasureShortInstantiation(variable: java!CompilationUnit) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -293,10 +296,15 @@ rule MeasureShortInstantiation(variable : java!CompilationUnit) {
),
noc: smm!DimensionalMeasure (
name <- 'ShortInstantiation',
shortDescription <- 'Calling new Short() causes memory allocation that can be avoided by the static Short.valueOf(). It makes use of an internal cache that recycles earlier instances making it more memory efficient. Note that new Short() is deprecated since JDK 9 for that reason.'
shortDescription <- 'Calling new Short() causes memory allocation that can be'
+ ' avoided by the static Short.valueOf(). It makes use of an'
+ ' internal cache that recycles earlier instances making it more'
+ ' memory efficient. Note that new Short() is deprecated since JDK 9'
+ ' for that reason.'
),
measurement: smm!DirectMeasurement (
error<-'In the Class '+ variable.name + ' an instantiation of Short must be Short.ValueOf().'
error <- 'In the Class ' + variable.name + ' an instantiation of Short must'
+ ' be Short.ValueOf().'
)
do {
......@@ -304,10 +312,10 @@ rule MeasureShortInstantiation(variable : java!CompilationUnit) {
}
}
--------------------------------------------- LongInstantiation ---------------------------------------------
--------------------------------------------- LongInstantiation
--- ---------------------------------------------
-- A Measure instance if the class violates the rule 'LongInstantiation'.
rule MeasureLongInstantiation(variable : java!CompilationUnit) {
rule MeasureLongInstantiation(variable: java!CompilationUnit) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -315,10 +323,15 @@ rule MeasureLongInstantiation(variable : java!CompilationUnit) {
),
noc: smm!DimensionalMeasure (
name <- 'LongInstantiation',
shortDescription <- 'Calling new Long() causes memory allocation that can be avoided by the static Long.valueOf(). It makes use of an internal cache that recycles earlier instances making it more memory efficient. Note that new Long() is deprecated since JDK 9 for that reason.'
shortDescription <- 'Calling new Long() causes memory allocation that can be'
+ ' avoided by the static Long.valueOf(). It makes use of an internal'
+ ' cache that recycles earlier instances making it more memory'
+ ' efficient. Note that new Long() is deprecated since JDK 9 for'
+ ' that reason.'
),
measurement: smm!DirectMeasurement (
error<-'In the Class '+ variable.name + ' an instantiation of Long must be Long.ValueOf().'
error <- 'In the Class ' + variable.name + ' an instantiation of Long must be'
+ ' Long.ValueOf().'
)
do {
......@@ -326,9 +339,10 @@ rule MeasureLongInstantiation(variable : java!CompilationUnit) {
}
}
--------------------------------------------- DoNotExtendJavaLangThrowable ---------------------------------------------
--------------------------------------------- DoNotExtendJavaLangThrowable
--- ---------------------------------------------
-- A Measure instance if the class violates the rule DoNotExtendJavaLangThrowable.
rule MeasureDoNotExtendJavaLangThrowable(variable : java!ClassDeclaration) {
rule MeasureDoNotExtendJavaLangThrowable(variable: java!ClassDeclaration) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -336,11 +350,12 @@ rule MeasureDoNotExtendJavaLangThrowable(variable : java!ClassDeclaration) {
),
noc: smm!DimensionalMeasure (
name <- 'DoNotExtendJavaLangThrowable ',
shortDescription <- 'Extend Exception or RuntimeException instead of Throwable.'
shortDescription <- 'Extend Exception or RuntimeException instead of'
+ ' Throwable.'
),
measurement: smm!DirectMeasurement (
error<-'In the Class '+ variable.name + ' should not extend Throwable but RuntimeException or Exception .'
error <- 'In the Class ' + variable.name + ' should not extend Throwable but'
+ ' RuntimeException or Exception .'
)
do {
......@@ -349,31 +364,31 @@ rule MeasureDoNotExtendJavaLangThrowable(variable : java!ClassDeclaration) {
}
-- Returns the number of branches in the switch statement passed in parameter
helper def: nbBranchesOfASwitchStatement(switchStatement:java!SwitchStatement) : Integer =
switchStatement.statements->select(each | each.oclIsTypeOf(java!SwitchCase)).size()
;
helper def: nbBranchesOfASwitchStatement(switchStatement: java!SwitchStatement): Integer =
switchStatement.statements -> select(each | each.oclIsTypeOf(java!SwitchCase)).size();
-- Returns the number of Fields in Class
helper def: numberFieldsInClasse(s:java!ClassDeclaration) : Integer =
helper def: numberFieldsInClasse(s: java!ClassDeclaration): Integer =
-- Return the number of FieldDeclaration in a class.
s.bodyDeclarations-> select(r | r.oclIsTypeOf(java!FieldDeclaration))->size();
s.bodyDeclarations -> select(r | r.oclIsTypeOf(java!FieldDeclaration)) -> size();
-- Returns the number of breaks of the switch statement passed in parameter
helper def: nbBreakStatementOfASwitchStatement(ss:java!SwitchStatement) : Integer =
ss.statements->select(each | each.oclIsTypeOf(java!BreakStatement)).size()
;
helper def: nbBreakStatementOfASwitchStatement(ss: java!SwitchStatement): Integer =
ss.statements -> select(each | each.oclIsTypeOf(java!BreakStatement)).size();
-- Returns the number of expressions of the switch statement passed in parameter
helper def: nbExpressionsStatementOfASwitchStatement(ss:java!SwitchStatement) : Integer =
ss.statements->select(each | each.oclIsTypeOf(java!ExpressionStatement)).size()
;
-- Returns the number of intentional fall-through (empty switch cases) of a switchStatement
helper def: nbIntentionalFallThroughOfASwitchStatement(ss:java!SwitchStatement) : Integer =
thisModule.nbBranchesOfASwitchStatement(ss) - thisModule.nbExpressionsStatementOfASwitchStatement(ss)
;
-- Creates an instance of Measure for the switch statement missing one or more break statements
helper def: nbExpressionsStatementOfASwitchStatement(ss: java!SwitchStatement): Integer =
ss.statements -> select(each | each.oclIsTypeOf(java!ExpressionStatement)).size();
-- Returns the number of intentional fall-through (empty switch cases) of a
-- switchStatement
helper def: nbIntentionalFallThroughOfASwitchStatement(ss: java!SwitchStatement): Integer
=
thisModule.nbBranchesOfASwitchStatement(ss) - thisModule.
nbExpressionsStatementOfASwitchStatement(ss);
-- Creates an instance of Measure for the switch statement missing one or more break
-- statements
-- To test, use input model : missing-break-in-switch.xmi
rule createMeasureForMissingBreakInSwitch(ss: java!SwitchStatement) {
to
......@@ -383,12 +398,17 @@ rule createMeasureForMissingBreakInSwitch(ss: java!SwitchStatement) {
),
missingBreakInSwitch: smm!DimensionalMeasure (
name <- 'Missing break in Switch',
shortDescription <- 'Switch statements without break or return statements for each case option may indicate problematic behaviour. Empty cases are ignored as these indicate an intentional fall-through.'
shortDescription <- 'Switch statements without break or return statements for'
+ ' each case option may indicate problematic behaviour. Empty cases'
+ ' are ignored as these indicate an intentional fall-through.'
),
measurement: smm!DirectMeasurement (
error <- 'Missing breaks in Switch in Class : ' + ss.originalCompilationUnit.name + '',
error <- 'Missing breaks in Switch in Class : ' + ss.originalCompilationUnit.
name + '',
-- Indicates the number of breaks missing in the switch statement
value <- (thisModule.nbBranchesOfASwitchStatement(ss) - thisModule.nbIntentionalFallThroughOfASwitchStatement(ss)) - thisModule.nbBreakStatementOfASwitchStatement(ss)
value <- (thisModule.nbBranchesOfASwitchStatement(ss) - thisModule.
nbIntentionalFallThroughOfASwitchStatement(ss)) - thisModule.
nbBreakStatementOfASwitchStatement(ss)
)
do {
missingBreakInSwitch;
......@@ -396,7 +416,7 @@ rule createMeasureForMissingBreakInSwitch(ss: java!SwitchStatement) {
}
-- A Measure instance if the class violates the rule 'TooManyMethods'.
rule MesureTooManyMethods(class : java!ClassDeclaration) {
rule MesureTooManyMethods(class: java!ClassDeclaration) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -404,7 +424,9 @@ rule MesureTooManyMethods(class : java!ClassDeclaration) {
),
noc: smm!DimensionalMeasure (
name <- 'TooManyMethods',
shortDescription <- '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.'
shortDescription <- '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.'
),
measurement: smm!DirectMeasurement (
error <- class.originalCompilationUnit.name + ' has too many methods'
......@@ -416,7 +438,7 @@ rule MesureTooManyMethods(class : java!ClassDeclaration) {
}
-- A Measure instance if the class violates the rule ReturnFromFinallyBlock.
rule MesureReturnFromFinallyBlock(method : java!MethodDeclaration) {
rule MesureReturnFromFinallyBlock(method: java!MethodDeclaration) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -424,10 +446,13 @@ rule MesureReturnFromFinallyBlock(method : java!MethodDeclaration) {
),
noc: smm!DimensionalMeasure (
name <- 'returnFromFinallyBlock',
shortDescription <- 'Avoid returning from a finally block, this can discard exceptions.'
shortDescription <- 'Avoid returning from a finally block, this can discard'
+ ' exceptions.'
),
measurement: smm!DirectMeasurement (
error <- 'The method ' + method.name + ' in the class ' + method.originalCompilationUnit.name + ' has a return statement in a finally block.'
error <- 'The method ' + method.name + ' in the class ' + method.
originalCompilationUnit.name + ' has a return statement in a finally'
+ ' block.'
)
do {
noc;
......@@ -435,7 +460,7 @@ rule MesureReturnFromFinallyBlock(method : java!MethodDeclaration) {
}
-- A Measure instance if the class violates the rule 'TooManyStaticImports'.
rule MesureTooManyStaticImports(class : java!CompilationUnit) {
rule MesureTooManyStaticImports(class: java!CompilationUnit) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -443,7 +468,12 @@ rule MesureTooManyStaticImports(class : java!CompilationUnit) {
),
noc: smm!DimensionalMeasure (
name <- 'TooManyStaticImports',
shortDescription <- 'If you overuse the static import feature, it can make your program unreadable and unmaintainable, polluting its namespace with all the static members you import. Readers of your code (including you, a few months after you wrote it) will not know which class a static member comes from (Sun 1.5 Language Guide).'
shortDescription <- 'If you overuse the static import feature, it can make'
+ ' your program unreadable and unmaintainable, polluting its'
+ ' namespace with all the static members you import. Readers of your'
+ ' code (including you, a few months after you wrote it) will not'
+ ' know which class a static member comes from (Sun 1.5 Language'
+ ' Guide).'
),
measurement: smm!DirectMeasurement (
error <- class.name + ' has too many static imports'
......@@ -454,7 +484,7 @@ rule MesureTooManyStaticImports(class : java!CompilationUnit) {
}
-- creates a new Measure when the method printStackTrace is used
rule MeasureAvoidPrintStackTrace(method : java!MethodInvocation) {
rule MeasureAvoidPrintStackTrace(method: java!MethodInvocation) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -465,7 +495,8 @@ rule MeasureAvoidPrintStackTrace(method : java!MethodInvocation) {
shortDescription <- 'Avoid printStackTrace(); use a logger call instead.'
),
measurement: smm!DirectMeasurement (
error<- 'The class '+ method.originalCompilationUnit.name + ' violates the rule avoid print stack trace.'
error <- 'The class ' + method.originalCompilationUnit.name + ' violates the'
+ ' rule avoid print stack trace.'
)
do {
noc;
......@@ -473,7 +504,7 @@ rule MeasureAvoidPrintStackTrace(method : java!MethodInvocation) {
}
-- creates a new Measure when Thread.run() is used instead of Thread.start()
rule measureAvoidThreadGroup(variable : java!VariableDeclarationFragment) {
rule measureAvoidThreadGroup(variable: java!VariableDeclarationFragment) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -481,10 +512,13 @@ rule measureAvoidThreadGroup(variable : java!VariableDeclarationFragment) {
),
noc: smm!DimensionalMeasure (
name <- 'Avoid Thread Group',
shortDescription <- 'Avoid using java.lang.ThreadGroup; although it is intended to be used in a threaded environment it contains methods that are not thread-safe.'
shortDescription <- 'Avoid using java.lang.ThreadGroup; although it is'
+ ' intended to be used in a threaded environment it contains methods'
+ ' that are not thread-safe.'
),
measurement: smm!DirectMeasurement (
error<-'The class '+ variable.originalCompilationUnit.name + ' violates the rule avoid thread group.'
error <- 'The class ' + variable.originalCompilationUnit.name + ' violates'
+ ' the rule avoid thread group.'
)
do {
......@@ -492,9 +526,11 @@ rule measureAvoidThreadGroup(variable : java!VariableDeclarationFragment) {
}
}
--------------------------------------------- AvoidThrowingNewInstanceOfSameException ---------------------------------------------
-- A Measure instance if the class violates the rule 'AvoidThrowingNewInstanceOfSameException'.
rule MeasureAvoidThrowingNewInstanceOfSameException(catch : java!CatchClause) {
--------------------------------------------- AvoidThrowingNewInstanceOfSameException
--- ---------------------------------------------
-- A Measure instance if the class violates the rule
-- 'AvoidThrowingNewInstanceOfSameException'.
rule MeasureAvoidThrowingNewInstanceOfSameException(catch: java!CatchClause) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -502,19 +538,24 @@ rule MeasureAvoidThrowingNewInstanceOfSameException(catch : java!CatchClause) {
),
noc: smm!DimensionalMeasure (
name <- 'AvoidThrowingNewInstanceOfSameException',
shortDescription <- 'Catch blocks that merely rethrow a caught exception wrapped inside a new instance of the same type only add to code size and runtime complexity.'
shortDescription <- 'Catch blocks that merely rethrow a caught exception'
+ ' wrapped inside a new instance of the same type only add to code'
+ ' size and runtime complexity.'
),
measurement: smm!DirectMeasurement (
error <-'The class '+ catch.originalCompilationUnit.name + ' has a method that rethrows a caught exception wrapped inside a new instance of the same type.'
error <- 'The class ' + catch.originalCompilationUnit.name + ' has a method'
+ ' that rethrows a caught exception wrapped inside a new instance of'
+ ' the same type.'
)
do {
noc;
}
}
--------------------------------------------- ReturnEmptyArrayRatherThanNull ---------------------------------------------
--------------------------------------------- ReturnEmptyArrayRatherThanNull
--- ---------------------------------------------
-- creates a new Measure when a method returns an empty method rather than null
rule MesureReturnEmptyArrayRatherThanNull(method : java!ReturnStatement) {
rule MesureReturnEmptyArrayRatherThanNull(method: java!ReturnStatement) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -522,19 +563,22 @@ rule MesureReturnEmptyArrayRatherThanNull(method : java!ReturnStatement) {
),
noc: smm!DimensionalMeasure (
name <- 'ReturnEmptyArrayRatherThanNull',
shortDescription <- 'For any method that returns an array, it is a better to return an empty array rather than a null reference.'
shortDescription <- 'For any method that returns an array, it is a better to'
+ ' return an empty array rather than a null reference.'
),
measurement: smm!DirectMeasurement (
error <- 'A method in the class ' + method.originalCompilationUnit.name + ' returns null instead of an empty array.'
error <- 'A method in the class ' + method.originalCompilationUnit.name + ''
+ ' returns null instead of an empty array.'
)
do {
noc;
}
}
--------------------------------------------- ExcessiveParameterList ---------------------------------------------
--------------------------------------------- ExcessiveParameterList
--- ---------------------------------------------
-- creates a new Measure when a method has more than 10 parameters
rule MesureExcessiveParameterList(method : java!MethodDeclaration) {
rule MesureExcessiveParameterList(method: java!MethodDeclaration) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -542,10 +586,12 @@ rule MesureExcessiveParameterList(method : java!MethodDeclaration) {
),
noc: smm!DimensionalMeasure (
name <- 'ExcessiveParameterList',
shortDescription <- 'Methods with numerous parameters are a challenge to maintain, especially if most of them share the same datatype.'
shortDescription <- 'Methods with numerous parameters are a challenge to'
+ ' maintain, especially if most of them share the same datatype.'
),
measurement: smm!DirectMeasurement (
error<-'The method '+ method.name + ' in the class ' + method.originalCompilationUnit.name + ' has an excessive parameter list.'
error <- 'The method ' + method.name + ' in the class ' + method.
originalCompilationUnit.name + ' has an excessive parameter list.'
)
do {
noc;
......@@ -553,7 +599,8 @@ rule MesureExcessiveParameterList(method : java!MethodDeclaration) {
}
-- A Measure instance if the class violates the rule 'AvoidFieldNameMatchingMethodName'.
rule MesureAvoidFieldNameMatchingMethodName(class : java!ClassDeclaration, method : java!MethodDeclaration) {
rule MesureAvoidFieldNameMatchingMethodName(class: java!ClassDeclaration, method:
java!MethodDeclaration) {
to
om: smm!ObservedMeasure (
measure <- noc,
......@@ -561,10 +608,15 @@ rule MesureAvoidFieldNameMatchingMethodName(class : java!ClassDeclaration, metho
),
noc: smm!DimensionalMeasure (
name <- 'AvoidFieldNameMatchingMethodName',