Every Flex Rule in FlexPMD
3
package com.adobe.ac
{
import mx.controls.ComboBox; // VIOLATION
public class MyModelClass
{
}
}
Monkey patching can be a risky undertaking because it is not using intended extensibility points and thus may have unintended consequences or make migration to newer versions of the SDK more difficult
1
If you have different functionalities, you probably don't want every class of each to be accessible from any other functional areas.
So you probably want to use this packaging:
[org].[project].func1.api
[org].[project].func1.restricted
[org].[project].func2.api
[org].[project].func2.restricted
This rule makes sure that no restricted classes is accessed from outside its own function area.
1
package functional
{
import functional.func1.api.Func1ExposedClass;
import functional.func1.restricted.Func1RestrictedClass; // VIOLATION
import functional.func2.api.Func2ExposedClass;
import functional.func2.restricted.Func2RestrictedClass; // VIOLATION
public class FunctionClient
{
}
}
package functional.func1.api
{
import functional.func1.restricted.Func1RestrictedClass;
import functional.func2.api.Func2ExposedClass;
import functional.func2.restricted.Func2RestrictedClass; // VIOLATION
public class Func1ExposedClass
{
}
}
package functional.func1.restricted
{
import functional.func1.api.Func1ExposedClass;
import functional.func2.api.Func2ExposedClass;
import functional.func2.restricted.Func2RestrictedClass; // VIOLATION
public class Func1RestrictedClass
{
}
}
package functional.func2.api
{
import functional.func1.api.Func1ExposedClass;
import functional.func1.restricted.Func1RestrictedClass; // VIOLATION
import functional.func2.restricted.Func2RestrictedClass;
public class Func2ExposedClass
{
}
}
package functional.func2.restricted
{
import functional.func1.api.Func1ExposedClass;
import functional.func1.restricted.Func1RestrictedClass; // VIOLATION
import functional.func2.api.Func2ExposedClass;
public class Func2RestrictedClass
{
}
}
3
3
3
5
3
3
50
Code behind files are tightly coupled with the view, not unit-testable, not easy to navigate the code code base and not reusable. Try using presentation model pattern, or observer pattern
5
3
5
1
public class Controller extends FrontController
{
public function Controller()
{
BindingUtils.bindSetter(setContent, value, "content"); // VIOLATION
}
}
1
public final class Title
{
private var watcher : ChangeWatcher; // VIOLATION
}
A Binding expression is executed as soon as one of the bindable attributes changed. If a binding expression contains too many expression, there could be some performance issue.
3
3
]]>
A bindable ModelLocator could leads to performance issues due to bindings
1
[Bindable]
public class BindableModelLocator // VIOLATION
{
}
The ModelLocator should be only accessible from the main application file. Then sub-models should be injected to the nested views.
3
package business
{
import model.MyModelLocator; // VIOLATION
public class MyBusinessClass
{
}
}
Try split them into methods where you add commands depending on their functional area.
3
package control
{
import control.GetItems1Command;
import control.GetItems1Event;
import control.GetItems2Command;
import control.GetItems2Event;
// A lot of other imports
public class MyFrontController // VIOLATION
{
public function MyFrontController()
{
addCommand(
GetItems1Event.EVENT_NAME,
GetItems1Command );
addCommand(
GetItems2Event.EVENT_NAME,
GetItems2Command );
// A lot of other addCommand
}
}
}
You would have something like 'productManagement.getProducts' as an event name.
3
public class UncorrectConstructorEvent extends CairngormEvent
{
public function UncorrectConstructorEvent( model : IModel )
{
super( "eventName", model ); // VIOLATION. It should be "functionalArea.eventName" instead
}
}
public class UncorrectConstantEvent extends CairngormEnterpriseEvent
{
public static const EVENT_NAME : String = "eventName";
public function UncorrectConstantEvent( model : IModel )
{
super( EVENT_NAME, model ); // VIOLATION
}
}
3
3
UpdateDisplayList is called everytime a child is invalidated. So calling addChild or removeChild in this function could be really CPU consuming
1
If you needed to call 'callLater' explicitly, then you probably did not extend the correct component life cycle.
1
It is not a good practice to embed style blocks inside the MXML component. Prefer using external CSS files.
3
5
3
public class Foo
{
public function bar( x : int ) : void
{
try
{
}
catch( e : Exception ) // VIOLATION
{
}
}
}
Empty If Statement finds instances where a condition is checked but nothing is done about it.
3
public class Foo
{
public function bar( x : int ) : void
{
if ( x == 0 )
{
// VIOLATION
}
}
}
When creating your own custom Event class, you must override the inherited Event.clone() method in order for it to duplicate the properties of your custom class. If you do not set all the properties that you add in your event subclass, those properties will not have the correct values when the event is cloned. This is important because the Flex SDK clones events whenever redispatching takes place.
1
public class FirstCustomEvent // VIOLATION - clone method is missing
{
public var lala : String;
public function FirstCustomEvent()
{
}
}
In order to improve encapsulation in your custom event, it is better not to have public variable in your event. Prefer having read-only attributes, set by the event constructor.
3
public class FirstCustomEvent
{
public var lala : String; // VIOLATION
public function FirstCustomEvent()
{
}
}
This is pointless, since event listeners cannot be attached to an object before it has been constructed, so nothing can ever hear the event
1
public class BigModel
{
public function BigModel()
{
dispatchEvent( new Event( "pointlessEvent" ) );
}
}
3
public class DefaultNameEvent extends Event
{
public function DefaultNameEvent( type : String = "" )
{
super( type );
}
}
You should not dispatch a plain string. If you rename this string, you need to replace the string listener as well. Use constants instead
1
public class Foo
{
public function bar() : void
{
dispatch( new Event( "myHardCodedEvent" ) ); // VIOLATION
}
}
You should not listen for a plain string. If you rename this string, you need to replace the string listener as well. Use constants instead
1
public class Foo
{
public function bar() : void
{
addEventListener( "myHardCodedEvent", handleMyHardCodedEvent ); // VIOLATION
}
}
1
[Event(name="myTypeEvent",type="UnknownType")] // VIOLATION
public class UnboundMetadata
{
}
Specifying a type will allow Flash builder and the class to have this event exposed in its API
3
[Event(name="myTypeEvent")] // VIOLATION
public class UnTypedMetadata
{
}
3
You should not Alert.show() directly. If an error occurred in the system, you should probably use an ErrorManager to have a consistent way to manage those errors.
1
A high number of imports can indicate a high degree of coupling within an object. Rule counts the number of unique imports and reports a violation if the count is above the user defined threshold.
3
15
import blah.blah.Baz;
import blah.blah.Bif;
// 18 others from the same package elided
public class Foo
{
public function doWork() : void
{
}
}
3
if ( true ) // VIOLATION
{
if ( myCondition == false ) // VIOLATION
{
}
}
3
When using dynamic classes, you cannot control how the developer will use your class. It makes refactoring really difficult
1
dynamic public class DynamicObject // VIOLATION
{
}
It is a bad practice to use the dynamic class Object. Prefer using strongly typed object, or marker interface in order to avoid silent compilation errors while refactoring
1
public class Foo
{
public var bar : Object; // VIOLATION
}
It is a bad practice to use the dynamic class Dictionary. Prefer using strongly typed object, or marker interface in order to avoid silent compilation errors while refactoring
1
public class Foo
{
public var bar : Dictionnary; // VIOLATION
}
1
public class MyObject {
public static const MY_STATIC_CONSTANT : String = "myStaticConstant";
public const MY_NON_STATIC_CONSTANT : String = "myStaticConstant"; // VIOLATION
}
1
public class Foo
{
public var bar : *; // VIOLATION
}
This function is not needed.
3
override protected function createChildren() : void
{
super.createChildren();
}
3
final public class Foo
{
protected var bar : int; // VIOLATION
}
3
3
public class ArrayVO {
public var items:Array; //VIOLATION
[ArrayElementType("model.vo.MenuItemVO")]
public var menuItems : Array;
}
3
package com.MyCompany
{
public class SomeClass extends mx.SomeClass // VIOLATION
{
}
}
3
protected static function foo() : void // VIOLATION
{
}
5
protected function foo() : void
{
var i : int = 0;
; // VIOLATION
}
1
package
{
public class Foo
{
public static const XYZ:String = XYZ; // meant to be "xyz"
}
}
1
1
Detects when a field, local, or parameter has a very short name.
5
3
public class Something
{
private var q : int = 15; // VIOLATION - Field
public function foo( as : String ) : void // VIOLATION - Formal
{
var r : int = 20 + q; // VIOLATION - Local
}
}
Detects when a package definition contains upper case characters.
3
3
3
public class SomeClass
{
public var myField : int = 0;
public function foo() : void
{
var myField : int = 9; // VIOLATION
}
}
3
public class foo // VIOLATION
{
}
3
5
3
1
5
3
5
on
Parsley can only process metadata that is placed onto public members.
1
[MessageHandler]
private function doSomething() : void // VIOLATION
{
}
Each managed event should have matching [Event] metadata.
1
[Event(name="message", type="my.package.MyEvemt")]
[ManagedEvents(names="messag")] // VIOLATION
public class MyClass
{
}
1
1
3
3
1
3
10
3
1
3
5
3
A recursive style manager call can be a very expensive operation, causing parts of the UI to flicker visibly. Instead it is preferable to defer the creation of parts of the UI that depend on a runtime CSS SWF until after the SWF has been loaded. In this case a recursive call is not required.
3
5
var position:Number = Math.floor ( floatingValue );
5
var position:Number = Math.ceil ( floatingValue );
5
var position:Number = Math.round ( floatingValue );
The security.exactSettings value should remain set at the default true value. Setting this value to false could make the SWF vulnerable to cross-domain attacks.
1
//exactSettings should be left as the default
Security.exactSettings = true;
The security.allowDomain value of "*" will allow any domain to cross-script into the domain of this SWF and exercise its functionality.
1
//The allowDomain settings should be specific
Security.allowDomain("www.example.org");
The LocalConnection.allowDomain value of "*" will allow any domain to connect to this SWF and call its functions.
1
//The allowDomain setting should be specific
LocalConnection.allowDomain("www.example.org");
Using allowInsecureDomain will allow untrusted content from an HTTP site to inject data into a trusted HTTPS connection which may comprimise the integrity of the HTTPS connection. The use of allowDomain is preferred.
1
//Use the allowDomain setting instead
LocalConnection.allowDomain("www.example.org");
Security.allowDomain("www.example.org");
If this SWF is being served over HTTPS then the secure flag should be set to true. This can help prevent sensitive SSL protected information from being shared within insecure HTTP content. If this SWF is served over HTTP then you can ignore this warning.
5
//Setting secure values for LSOs
LSO.getLocal(name, null, true);
If this loader is only intended to load image files (GIF,JPG,PNG) then be sure to set the allowCodeImport value to false. Setting this flag will reduce the chances of an untrusted SWF gaining access to your site. If your intent is to load a SWF, the URL for the request is a static value for a trusted site and/or you have already set the allowCodeImport flag, then you can ignore this warning.
5
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.
3
10
public class Foo
{
public function doWork() : void {}
public function doMoreWork() : void {}
public function doWorkAgain() : void {}
// [... more more public methods ...]
}
Violations of this rule usually indicate that the method has too much responsibility. Try to reduce the method size by creating helper methods and removing any copy/pasted code.
3
20
public class Foo
{
public function doSomething() : void
{
System.out.println("Hello world!");
System.out.println("Hello world!");
// 98 copies omitted for brevity.
}
}
A switch case statement should be either empty, or contain a break, or call another method.
3
3
public class Bar
{
public function foo() : void
{
var i : int = 4;
switch( i )
{
case 1:
handleFirstCase();
break;
case 2: // VIOLATION
googleResquest.url = "";
handleSecondCaseFirstPart();
handleSecondCaseSecondPart();
break;
}
}
}
Long parameter lists can indicate that a new object should be created to wrap the numerous parameters. Basically, try to group the parameters together.
3
4
public class Foo
{
public function addData( p0 : int, p1 : int, p2 : int, p3 : int, p4 : int, p5 : int,
p6 : int, p7 : int, p8 : int, p9 : int, p10 : int ) : void
{
}
}
A large number of public methods and attributes declared in a class can indicate the class may need to be broken up as increased effort will be required to thoroughly test it.
3
10
public class Foo
{
public var value : String;
public var something : Bar;
public var variable : Variable;
// [... more more public attributes ...]
public function doWork() : void {}
public function doMoreWork() : void {}
public function doWorkAgain() : void {}
// [... more more public methods ...]
}
Classes that have too many fields could be redesigned to have fewer fields, possibly through some nested object grouping of some of the information. For example, a class with city/state/zipcode fields could instead have one Address field.
3
5
public class Person
{
private var one : String;
private var two : int;
private var three : int;
[... many more public fields ...]
}
3
Even if this is syntactically correct, there should not be a return type for a constructor.
5
public class VoidConstructor
{
public function VoidConstructor() : void // VIOLATION
{
}
}
5
200
5
package com.adobe.ac
{
import com.adobe.ac.MyModel; // VIOLATION HERE
public class BigModel
{
public var model : MyModel = null;
}
}
5
5
Switch statements should have a default label in order to detect corner cases.
1
public class Foo
{
public funciton bar() : void
{
var x : int = 2;
switch (x)
{
case 2: var j : int = 8;
}
}
}
As a general practice, switch statement should not be used. Prefer using inheritance. It is even harder to read when switch statements are nested.
3
public function foo( a : Number, b : Number ) : void
{
switch( a )
{
case 1:
break;
case 2:
switch ( b )
{
case 3 :
break;
case 4 :
break;
}
break;
}
}
1
switch(event.type){
case GoogleSearchPanel.LAUNCH_GOOGLE_WEB_SEARCH:
googleResquest.url = ""; // VIOLATION
case GoogleSearchPanel.LAUNCH_GOOGLE_IMAGE_SEARCH:
case GoogleSearchPanel.LAUNCH_GOOGLE_IMAGE_SEARCH2:
googleResquest.url = "";
break;
default:
return;
}
Switch statements are designed for complex branches, and allow branches to share treatment. Using a switch for only 2 branches is ill advised, as switches are not as easy to understand as if. In this case, it's most likely is a good idea to use a if statement
5
3
1
3
1
public function foo( param1 : Number, param2 : Number, param3 : Number, param4 : Number, param5 : Number ) : void // 4 violations
{
var i : int = param1;
}
3
public function foo() : void
{
var i : int = 0;// 1 violation
}
1
1
1