Merge pull request #3 from mgechev/property-directive

Property directive

Author: mgechev

.gitignore

@@ -1,4 +1,4 @@
 node_modules
 typings
 dist
-
+.idea

README.md

@@ -17,7 +17,9 @@ Below you can find a recommended configuration which is based on the [Angular 2
   "host-parameter-decorator": true,
   "input-parameter-decorator": true,
   "output-parameter-decorator": true,
-  "attribute-parameter-decorator":true
+  "attribute-parameter-decorator":true,
+  "input-property-directive":true,
+  "output-property-directive":true
 }
 ```
 
@@ -33,8 +35,8 @@ Below you can find a recommended configuration which is based on the [Angular 2
 - [x] Use `@Output` instead of `outputs` decorator property.
 - [x] Use `@HostListeners` and `@HostBindings` instead of `host` decorator property.
 - [ ] Do not use `nativeElement` injected with `ElementRef`.
-- [ ] Do not rename inputs.
-- [ ] Do not rename outputs.
+- [x] Do not rename inputs.
+- [x] Do not rename outputs.
 - [ ] Externalize template above *n* lines of code.
 - [x] Do not use the `@Attribute` decorator.
 - [ ] Do not use `forwardRef`.

src/attributeParameterDecoratorRule.ts

@@ -1,29 +1,19 @@
 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;
-};
+import {decoratorValidator} from "./util/decoratorValidator";
 
 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"';
 
+const attributeCondition = (name)=>{
+    return (name=='Attribute')
+};
+
 export class Rule extends ConstructorRule {
 
     constructor(ruleName:string, value:any, disabledIntervals:Lint.IDisabledInterval[]) {
-        super(ruleName, value, disabledIntervals,attributeValidator,FAILURE_STRING);
+        super(ruleName, value, disabledIntervals,decoratorValidator(attributeCondition),FAILURE_STRING);
     }
 
 }

src/inputPropertyDirectiveRule.ts

@@ -0,0 +1,19 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {ClassParameterRule} from "./propertyClassBase";
+import {decoratorValidator} from './util/decoratorValidator';
+
+const FAILURE_STRING = 'In the class "%s", the directive input property "%s" should not be renamed.' +
+    'Please, consider the following use "@Input() %s: string"';
+
+const renameInputCondition = (name, arg)=> {
+    return (name === 'Input' && arg);
+};
+
+export class Rule extends ClassParameterRule {
+
+    constructor(ruleName:string, value:any, disabledIntervals:Lint.IDisabledInterval[]) {
+        super(ruleName, value, disabledIntervals, decoratorValidator(renameInputCondition), FAILURE_STRING);
+    }
+
+}

src/outputPropertyDirectiveRule.ts

@@ -0,0 +1,19 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {ClassParameterRule} from "./propertyClassBase";
+import {decoratorValidator} from './util/decoratorValidator';
+
+const FAILURE_STRING = 'In the class "%s", the directive output property "%s" should not be renamed.' +
+    'Please, consider the following use "@Output() %s = new EventEmitter();"';
+
+const renameOutputCondition = (name, arg)=> {
+    return (name === 'Output' && arg);
+};
+
+export class Rule extends ClassParameterRule {
+
+    constructor(ruleName:string, value:any, disabledIntervals:Lint.IDisabledInterval[]) {
+        super(ruleName, value, disabledIntervals, decoratorValidator(renameOutputCondition), FAILURE_STRING);
+    }
+
+}

src/propertyClassBase.ts

@@ -0,0 +1,58 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {sprintf} from 'sprintf-js';
+
+export class ClassParameterRule 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 ClassMetadataWalker(
+                sourceFile,
+                languageService,
+                this));
+    }
+
+    public validate(parameter:ts.ParameterDeclaration) {
+        return this.validator(parameter);
+    }
+
+    public getFailureString(failureConfig) {
+        return sprintf(this.errorMessage, failureConfig.className, failureConfig.memberName, failureConfig.memberName);
+    }
+}
+
+export class ClassMetadataWalker extends Lint.RuleWalker {
+
+    private languageService:ts.LanguageService;
+    private typeChecker:ts.TypeChecker;
+
+    constructor(sourceFile:ts.SourceFile, languageService:ts.LanguageService, private rule:ClassParameterRule) {
+        super(sourceFile, rule.getOptions());
+        this.languageService = languageService;
+        this.typeChecker = languageService.getProgram().getTypeChecker();
+    }
+
+    visitClassDeclaration(node:ts.ClassDeclaration) {
+        (node.members || []).forEach(this.validateClassMember.bind(this, node.name.text));
+        super.visitClassDeclaration(node);
+    }
+
+    validateClassMember(className:string, member) {
+        if (!this.rule.validate(member)) {
+            let memberName = member.name.text;
+            this.addFailure(
+                this.createFailure(
+                    member.getStart(),
+                    member.getWidth(),
+                    this.rule.getFailureString({className, memberName})));
+        }
+    }
+}

src/util/decoratorValidator.ts

@@ -0,0 +1,18 @@
+export const decoratorValidator = (condition)=> {
+    return function (element) {
+        let isValid:boolean = true;
+        if (element.decorators) {
+            element.decorators.forEach((decorator)=> {
+                let baseExpr = <any>decorator.expression || {};
+                let expr = baseExpr.expression || {};
+                let name = expr.text;
+                let args = baseExpr.arguments || [];
+                let arg = args[0];
+                if (condition(name, arg)) {
+                    isValid = false;
+                }
+            })
+        }
+        return isValid;
+    }
+};

test/attributeParameterDecoratorRule.spec.ts

@@ -10,7 +10,7 @@ describe('attribute-parameter-decorator', () => {
                     this.label = label;
                 }
             }`;
-            assertFailure('decorator-attribute', source, {
+            assertFailure('attribute-parameter-decorator', 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: {

test/inputPropertyDirectiveRule.spec.ts

@@ -0,0 +1,33 @@
+import {assertFailure, assertSuccess} from './testHelper';
+
+describe('input-property-directive', () => {
+    describe('invalid directive input property', () => {
+        it(`should fail, when a directive input property is renamed`, () => {
+            let source = `
+            class ButtonComponent {
+                @Input('labelAttribute') label: string;
+            }`;
+            assertFailure('input-property-directive', source, {
+                message: 'In the class "ButtonComponent", the directive input property "label" should not be renamed.' +
+                'Please, consider the following use "@Input() label: string"',
+                startPosition: {
+                    line: 2,
+                    character: 16
+                },
+                endPosition: {
+                    line: 2,
+                    character: 55
+                }
+            });
+        });
+    });
+    describe('valid directive input property', () => {
+        it('should succeed, when a directive input property is properly used', () => {
+            let source = `
+            class ButtonComponent {
+              @Input() label: string;
+            }`;
+            assertSuccess('input-property-directive', source);
+        });
+    });
+});

test/outputPropertyDirectiveRule.spec.ts

@@ -0,0 +1,33 @@
+import {assertFailure, assertSuccess} from './testHelper';
+
+describe('output-property-directive', () => {
+    describe('invalid directive output property', () => {
+        it(`should fail, when a directive output property is renamed`, () => {
+            let source = `
+            class ButtonComponent {
+                @Output('changeEvent') change = new EventEmitter<any>();
+            }`;
+            assertFailure('output-property-directive', source, {
+                message: 'In the class "ButtonComponent", the directive output property "change" should not be renamed.'+
+                'Please, consider the following use "@Output() change = new EventEmitter();"',
+                startPosition: {
+                    line: 2,
+                    character: 16
+                },
+                endPosition: {
+                    line: 2,
+                    character: 72
+                }
+            });
+        });
+    });
+    describe('valid directive input property', () => {
+        it('should succeed, when a directive output property is properly used', () => {
+            let source = `
+            class ButtonComponent {
+               @Output() change = new EventEmitter<any>();
+            }`;
+            assertSuccess('output-property-directive', source);
+        });
+    });
+});