Merge pull request #1 from mgechev/attribute

Add: attribute rule and constructor walker, Update: attribute rule ad…

Author: mgechev

README.md

@@ -16,7 +16,8 @@ Below you can find a recommended configuration which is based on the [Angular 2
   "component-selector-prefix": [true, "sg"],
   "host-parameter-decorator": true,
   "input-parameter-decorator": true,
-  "output-parameter-decorator": true
+  "output-parameter-decorator": true,
+  "attribute-parameter-decorator":true
 }
 ```
 
@@ -35,7 +36,7 @@ Below you can find a recommended configuration which is based on the [Angular 2
 - [ ] Do not rename inputs.
 - [ ] Do not rename outputs.
 - [ ] Externalize template above *n* lines of code.
-- [ ] Do not use the `@Attribute` decorator.
+- [x] Do not use the `@Attribute` decorator.
 - [ ] Do not use `forwardRef`.
 - [ ] Rise a warning for impure pipes.
 - [ ] Do not declare global providers.

src/attributeParameterDecoratorRule.ts

@@ -0,0 +1,29 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {ConstructorRule} from "./parameterConstructorBase";
+
+const attributeValidator = (parameter:ts.ParameterDeclaration)=>{
+    let isValid = true;
+    if (parameter.decorators) {
+        parameter.decorators.forEach((decorator:ts.Decorator)=> {
+            let baseExpr = <any>decorator.expression || {};
+            let expr = baseExpr.expression || {};
+            let name = expr.text;
+            if (name==='Attribute') {
+                isValid = false
+            }
+        });
+    }
+    return isValid;
+};
+
+const FAILURE_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 Rule extends ConstructorRule {
+
+    constructor(ruleName:string, value:any, disabledIntervals:Lint.IDisabledInterval[]) {
+        super(ruleName, value, disabledIntervals,attributeValidator,FAILURE_STRING);
+    }
+
+}

src/parameterConstructorBase.ts

@@ -0,0 +1,60 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {sprintf} from 'sprintf-js';
+
+export class ConstructorRule extends Lint.Rules.AbstractRule {
+
+    constructor(ruleName:string, value:any, disabledIntervals:Lint.IDisabledInterval[], private validator:Function,
+                private errorMessage:string) {
+        super(ruleName, value, disabledIntervals);
+    }
+
+    public apply(sourceFile:ts.SourceFile):Lint.RuleFailure[] {
+        let documentRegistry = ts.createDocumentRegistry();
+        let languageServiceHost = Lint.createLanguageServiceHost('file.ts', sourceFile.getFullText());
+        let languageService:ts.LanguageService = ts.createLanguageService(languageServiceHost, documentRegistry);
+        return this.applyWithWalker(
+            new ConstructorMetadataWalker(
+                sourceFile,
+                languageService,
+                this));
+    }
+
+    public validate(parameter:ts.ParameterDeclaration) {
+        return this.validator(parameter);
+    }
+
+    public getFailureString(failureConfig) {
+        return sprintf(this.errorMessage, failureConfig.className, failureConfig.parameterName, failureConfig.parameterName);
+    }
+}
+
+export class ConstructorMetadataWalker extends Lint.RuleWalker {
+
+    private languageService:ts.LanguageService;
+    private typeChecker:ts.TypeChecker;
+
+    constructor(sourceFile:ts.SourceFile, languageService:ts.LanguageService, private rule:ConstructorRule) {
+        super(sourceFile, rule.getOptions());
+        this.languageService = languageService;
+        this.typeChecker = languageService.getProgram().getTypeChecker();
+    }
+
+    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:ts.ParameterDeclaration) {
+        let parameterName = (<ts.Identifier>parameter.name).text;
+        if (!this.rule.validate(parameter)) {
+            this.addFailure(
+                this.createFailure(
+                    parameter.getStart(),
+                    parameter.getWidth(),
+                    this.rule.getFailureString({className, parameterName})));
+        }
+    }
+
+}

test/attributeParameterDecoratorRule.spec.ts

@@ -0,0 +1,36 @@
+import {assertFailure, assertSuccess} from './testHelper';
+
+describe('attribute-parameter-decorator', () => {
+    describe('invalid parameter decorator', () => {
+        it(`should fail, when it's used attribute decorator`, () => {
+            let source = `
+            class ButtonComponent {
+                label: string;
+                constructor(public @Attribute('label') label) {
+                    this.label = label;
+                }
+            }`;
+            assertFailure('decorator-attribute', source, {
+                message: 'In the constructor of class "ButtonComponent", the parameter "label" uses the @Attribute decorator, ' +
+                'which is considered as a bad practice. Please, consider construction of type "@Input() label: string"',
+                startPosition: {
+                    line: 3,
+                    character: 35
+                },
+                endPosition: {
+                    line: 3,
+                    character: 60
+                }
+            });
+        });
+    });
+    describe('valid class constructor', () => {
+        it('should succeed, when is not used attribute decorator', () => {
+            let source = `
+            class ButtonComponent {
+                constructor(){}
+            }`;
+            assertSuccess('attribute-parameter-decorator', source);
+        });
+    });
+});