add life cycle hooks rule and updated README

Author: PreskoIsTheGreatest

README.md

@@ -20,7 +20,8 @@ Below you can find a recommended configuration which is based on the [Angular 2
   "attribute-parameter-decorator": true,
   "input-property-directive": true,
   "output-property-directive": true,
-  "call-forward-ref":true
+  "call-forward-ref":true,
+  "life-cycle-hook":true
 }
 ```
 
@@ -54,7 +55,7 @@ Below you can find a recommended configuration which is based on the [Angular 2
 - [ ] Locate tests in the same directory (rise optional warning when no test file is found).
 - [ ] Rise warning on complex logic inside of the templates.
 - [ ] Do not manipulate elements referenced within the template.
-- [ ] Implement life-cycle hooks explicitly.
+- [x] Implement life-cycle hooks explicitly.
 - [ ] Implement Pipe transform interface for pipes.
 - [ ] Proper naming for pipes (kebab-case, optionally prefixed).
 

src/lifeCycleHookRule.ts

@@ -0,0 +1,83 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {sprintf} from 'sprintf-js';
+import SyntaxKind = require('./util/syntaxKind');
+
+export class Rule extends Lint.Rules.AbstractRule {
+
+    public apply(sourceFile:ts.SourceFile):Lint.RuleFailure[] {
+        return this.applyWithWalker(
+            new ClassMetadataWalker(sourceFile,
+                this.getOptions()));
+    }
+
+    static  FAILURE_SINGLE:string = 'In class %s the method %s is a life cycle hook' +
+        ' and should implement the %s interface';
+
+    static FAILURE_MANY = 'In class %s the methods - %s' +
+        ' are life cycle hooks and should implement the interfaces: %s';
+
+    static HOOKS_PREFIX = 'ng';
+
+    static LIFE_CYCLE_HOOKS_NAMES:Array<any> = [
+        "OnChanges",
+        "OnInit",
+        "DoCheck",
+        "AfterContentInit",
+        "AfterContentChecked",
+        "AfterViewInit",
+        "AfterViewChecked",
+        "OnDestroy"
+    ]
+
+}
+
+export class ClassMetadataWalker extends Lint.RuleWalker {
+
+    visitClassDeclaration(node:ts.ClassDeclaration) {
+        let syntaxKind = SyntaxKind.current();
+        let className = node.name.text;
+
+        let interfaces = [];
+        if (node.heritageClauses) {
+            let interfacesClause = node.heritageClauses.filter(h=>h.token === syntaxKind.ImplementsKeyword);
+            if (interfacesClause.length !== 0) {
+                interfaces = interfacesClause[0].types.map(t=>(<any>t.expression).text);
+            }
+        }
+
+        let missing:Array<string> = this.extractMissing(node.members, syntaxKind, interfaces);
+
+        if (missing.length !== 0) {
+            this.addFailure(
+                this.createFailure(
+                    node.getStart(),
+                    node.getWidth(),
+                    sprintf.apply(this, this.formatFailure(className, missing))));
+        }
+    }
+
+
+    private extractMissing(members:ts.NodeArray<ts.ClassElement>,
+                           syntaxKind:SyntaxKind.SyntaxKind,
+                           interfaces:Array<string>):Array<string> {
+        let ngMembers = members.filter(m=>m.kind === syntaxKind.MethodDeclaration)
+            .map(m=>(<any>m.name).text)
+            .filter(n=>n.substr(0, 2) === Rule.HOOKS_PREFIX)
+            .map(n=>n.substr(2, n.lenght))
+            .filter(n=>Rule.LIFE_CYCLE_HOOKS_NAMES.indexOf(n) !== -1);
+        return ngMembers.filter(m=>interfaces.indexOf(m) === -1);
+    }
+
+    private formatFailure(className:string, missing:Array<string>):Array<string> {
+        let failureConfig:Array<string>;
+        if (missing.length === 1) {
+            failureConfig = [Rule.FAILURE_SINGLE, className, Rule.HOOKS_PREFIX + missing[0], missing[0]];
+        } else {
+            let joinedNgMissing:string = missing.map(m=>Rule.HOOKS_PREFIX + m).join(', ');
+            let joinedMissingInterfaces = missing.join(', ');
+            failureConfig = [Rule.FAILURE_MANY, className, joinedNgMissing, joinedMissingInterfaces];
+        }
+        return failureConfig;
+    }
+}

test/lifeCycleHookRule.spec.ts

@@ -0,0 +1,104 @@
+import {assertFailure, assertSuccess} from './testHelper';
+
+describe('life-cycle-hook', () => {
+    describe('invalid declaration of life hook', () => {
+        it(`should fail, when a life cycle hook is used without implementing it's interface`, () => {
+            let source = `
+            class App {
+                ngOnInit(){
+                }
+            }`;
+            assertFailure('life-cycle-hook', source, {
+                message: 'In class App the method ngOnInit is a life cycle hook and should implement the OnInit interface',
+                startPosition: {
+                    line: 1,
+                    character: 12
+                },
+                endPosition: {
+                    line: 4,
+                    character: 13
+                }
+            });
+        });
+    });
+    describe('invalid declaration of life hooks', () => {
+        it(`should fail, when life cycle hooks are used without implementing their interfaces`, () => {
+            let source = `
+            class App {
+                ngOnInit(){
+                }
+                ngOnDestroy(){
+                }
+            }`;
+            assertFailure('life-cycle-hook', source, {
+                message: 'In class App the methods - ngOnInit, ngOnDestroy are life cycle hooks and ' +
+                'should implement the interfaces: OnInit, OnDestroy',
+                startPosition: {
+                    line: 1,
+                    character: 12
+                },
+                endPosition: {
+                    line: 6,
+                    character: 13
+                }
+            });
+        });
+    });
+    describe('invalid declaration of life hooks', () => {
+        it(`should fail, when some of the life cycle hooks are used without implementing their interfaces`, () => {
+            let source = `
+            class App extends Component implements OnInit{
+                ngOnInit(){
+                }
+                ngOnDestroy(){
+                }
+            }`;
+            assertFailure('life-cycle-hook', source, {
+                message: 'In class App the method ngOnDestroy is a life cycle hook and should implement the OnDestroy interface',
+                startPosition: {
+                    line: 1,
+                    character: 12
+                },
+                endPosition: {
+                    line: 6,
+                    character: 13
+                }
+            });
+        });
+    });
+    describe('valid declaration of life hook', () => {
+        it(`should succeed, when life cycle hook is used with it's corresponding interface`, () => {
+            let source = `
+            class App implements OnInit {
+                ngOnInit(){
+                }
+            }`;
+            assertSuccess('life-cycle-hook', source);
+        });
+    });
+    describe('valid declaration of life hooks', () => {
+        it(`should succeed, when life cycle hooks are used with their corresponding interfaces`, () => {
+            let source = `
+            class App extends Component implements OnInit,OnDestroy  {
+                ngOnInit(){
+                }
+
+                private ngOnChanges:string="";
+
+                ngOnDestroy(){
+                }
+
+                ngOnSmth{
+                }
+            }`;
+            assertSuccess('life-cycle-hook', source);
+        });
+    });
+    describe('valid use of class without interfaces and life cycle hooks', () => {
+        it(`should succeed when life cycle hooks are not used`, () => {
+            let source = `
+            class App{}`;
+            assertSuccess('life-cycle-hook', source);
+        });
+    });
+});