refactor(rules): use more explicit naming

Author: mgechev

README.md

@@ -31,18 +31,18 @@ Below you can find a recommended configuration which is based on the [Angular 2
   "component-selector-type": [true, "element"],
   "directive-selector-prefix": [true, "sg"],
   "component-selector-prefix": [true, "sg"],
-  "host-parameter-decorator": true,
-  "input-parameter-decorator": true,
-  "output-parameter-decorator": true,
-  "attribute-parameter-decorator": true,
-  "input-property-directive": true,
-  "output-property-directive": true,
-  "call-forward-ref" :true,
-  "life-cycle-hook": true,
-  "pipe-transform-interface": true,
-  "pipe-naming": [true, "kebab-case","sg"],
-  "component-class-suffix":true,
-  "directive-class-suffix":true
+  "use-host-parameter-decorator": true,
+  "use-input-parameter-decorator": true,
+  "use-output-parameter-decorator": true,
+  "no-attribute-parameter-decorator": true,
+  "no-input-rename": true,
+  "no-output-rename": true,
+  "no-forward-ref" :true,
+  "use-life-cycle-interface": true,
+  "use-pipe-transform-interface": true,
+  "pipe-naming": [true, "camelCase", "sg"],
+  "component-class-suffix": true,
+  "directive-class-suffix": true
 }
 ```
 

src/attributeParameterDecoratorRule.ts

@@ -0,0 +1,47 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {sprintf} from 'sprintf-js';
+
+export class Rule extends Lint.Rules.AbstractRule {
+
+    public apply(sourceFile:ts.SourceFile):Lint.RuleFailure[] {
+	return this.applyWithWalker(
+	    new ConstructorMetadataWalker(sourceFile,
+		this.getOptions()));
+    }
+
+    static  FAILURE_STRING:string = 'In the constructor of class "%s",' +
+	' the parameter "%s" uses the @Attribute decorator, ' +
+	'which is considered as a bad practice. Please,' +
+	' consider construction of type "@Input() %s: string"';
+
+}
+
+export class ConstructorMetadataWalker extends Lint.RuleWalker {
+
+    visitConstructorDeclaration(node:ts.ConstructorDeclaration) {
+	let parentName = (<ts.ClassDeclaration>node.parent).name.text;
+	(node.parameters || []).forEach(this.validateParameter.bind(this, parentName));
+	super.visitConstructorDeclaration(node);
+    }
+
+    validateParameter(className:string, parameter) {
+	let parameterName = (<ts.Identifier>parameter.name).text;
+	if (parameter.decorators) {
+	    parameter.decorators.forEach((decorator)=> {
+		let baseExpr = <any>decorator.expression || {};
+		let expr = baseExpr.expression || {};
+		let name = expr.text;
+		if (name == 'Attribute') {
+		    let failureConfig:string[] = [className, parameterName, parameterName];
+		    failureConfig.unshift(Rule.FAILURE_STRING);
+		    this.addFailure(
+			this.createFailure(
+			    parameter.getStart(),
+			    parameter.getWidth(),
+			    sprintf.apply(this, failureConfig)));
+		}
+	    })
+	}
+    }
+}

src/callForwardRefRule.ts

@@ -0,0 +1,39 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {sprintf} from 'sprintf-js';
+
+export class Rule extends Lint.Rules.AbstractRule {
+
+    public apply(sourceFile:ts.SourceFile):Lint.RuleFailure[] {
+	return this.applyWithWalker(
+	    new ExpressionCallMetadataWalker(sourceFile,
+		this.getOptions()));
+    }
+
+    static FAILURE_STRING:string = 'Avoid using forwardRef in class "%s"';
+}
+
+export class ExpressionCallMetadataWalker extends Lint.RuleWalker {
+
+    visitCallExpression(node:ts.CallExpression) {
+	this.validateCallExpression(node);
+	super.visitCallExpression(node);
+    }
+
+    private validateCallExpression(callExpression) {
+	if (callExpression.expression.text === 'forwardRef') {
+	    let currentNode:any = callExpression;
+	    while (currentNode.parent.parent) {
+		currentNode = currentNode.parent;
+	    }
+	    let failureConfig:string[] = [currentNode.name.text];
+	    failureConfig.unshift(Rule.FAILURE_STRING);
+	    this.addFailure(
+		this.createFailure(
+		    callExpression.getStart(),
+		    callExpression.getWidth(),
+		    sprintf.apply(this, failureConfig)));
+	}
+    }
+
+}

src/inputPropertyDirectiveRule.ts

@@ -0,0 +1,35 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {sprintf} from 'sprintf-js';
+import {Ng2Walker} from "./util/ng2Walker";
+
+export class Rule extends Lint.Rules.AbstractRule {
+
+    public apply(sourceFile:ts.SourceFile):Lint.RuleFailure[] {
+	return this.applyWithWalker(
+	    new InputMetadataWalker(sourceFile,
+		this.getOptions()));
+    }
+
+    static FAILURE_STRING:string = 'In the class "%s", the directive ' +
+	'input property "%s" should not be renamed.' +
+	'Please, consider the following use "@Input() %s: string"';
+}
+
+
+export class InputMetadataWalker extends Ng2Walker {
+
+    visitNg2Input(property:ts.PropertyDeclaration, input:ts.Decorator, args:string[]) {
+	let className = (<any>property).parent.name.text;
+	let memberName = (<any>property.name).text;
+	if (args.length != 0 && memberName != args[0]) {
+	    let failureConfig:string[] = [className, memberName, memberName];
+	    failureConfig.unshift(Rule.FAILURE_STRING);
+	    this.addFailure(
+		this.createFailure(
+		    property.getStart(),
+		    property.getWidth(),
+		    sprintf.apply(this, failureConfig)));
+	}
+    }
+}