Merge pull request #18 from mgechev/pipe-transform-interface

mgechev · mgechev · commit df81b7b7f646 · 2016-04-17T15:48:37.000+02:00
Pipe transform interface
diff --git a/README.md b/README.md
@@ -20,7 +20,9 @@ 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,
+  "pipe-transform-interface":true
 }
 ```
 
@@ -54,8 +56,8 @@ 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.
-- [ ] Implement Pipe transform interface for pipes.
+- [x] Implement life-cycle hooks explicitly.
+- [x] Implement Pipe transform interface for pipes.
 - [ ] Proper naming for pipes (kebab-case, optionally prefixed).
 
 ## License
diff --git a/src/lifeCycleHookRule.ts b/src/lifeCycleHookRule.ts
@@ -0,0 +1,84 @@
+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))));
+        }
+        super.visitClassDeclaration(node);
+    }
+
+
+    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;
+    }
+}
diff --git a/src/pipeTransformInterfaceRule.ts b/src/pipeTransformInterfaceRule.ts
@@ -0,0 +1,51 @@
+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:string = 'The %s class has the Pipe decorator, so it should implement the PipeTransform interface';
+
+    static  PIPE_INTERFACE_NAME = 'PipeTransform';
+}
+
+export class ClassMetadataWalker extends Lint.RuleWalker {
+
+    visitClassDeclaration(node:ts.ClassDeclaration) {
+        let decorators = node.decorators;
+        if (decorators) {
+            let pipes:Array<string> = decorators.map(d=>(<any>d.expression).expression.text).filter(t=>t === 'Pipe');
+            if (pipes.length !== 0) {
+                let className:string = node.name.text;
+                if (!this.hasIPipeTransform(node)) {
+                    this.addFailure(
+                        this.createFailure(
+                            node.getStart(),
+                            node.getWidth(),
+                            sprintf.apply(this, [Rule.FAILURE, className])));
+                }
+            }
+        }
+        super.visitClassDeclaration(node);
+    }
+
+    private hasIPipeTransform(node:ts.ClassDeclaration):boolean {
+        let interfaces = [];
+        if (node.heritageClauses) {
+            let interfacesClause = node.heritageClauses
+                .filter(h=>h.token === SyntaxKind.current().ImplementsKeyword);
+            if (interfacesClause.length !== 0) {
+                interfaces = interfacesClause[0].types
+                    .map(t=>(<any>t.expression).text);
+            }
+        }
+        return interfaces.indexOf(Rule.PIPE_INTERFACE_NAME) !== -1;
+    }
+}
diff --git a/test/lifeCycleHookRule.spec.ts b/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);
+        });
+    });
+});
diff --git a/test/pipeTransformInterfaceRule.spec.ts b/test/pipeTransformInterfaceRule.spec.ts
@@ -0,0 +1,42 @@
+import {assertFailure, assertSuccess} from './testHelper';
+
+describe('pipe-transform-interface', () => {
+    describe('invalid declaration of pipe', () => {
+        it(`should fail, when a Pipe is declared without implementing the PipeTransform interface`, () => {
+            let source = `
+                        @Pipe({name: 'fetch'})
+                        export class NewPipe{
+                          transform(url:string):any {
+                          }
+                        }`;
+            assertFailure('pipe-transform-interface', source, {
+                message: 'The NewPipe class has the Pipe decorator, so it should implement the PipeTransform interface',
+                startPosition: {
+                    line: 1,
+                    character: 24
+                },
+                endPosition: {
+                    line: 5,
+                    character: 25
+                }
+            });
+        });
+    });
+    describe('valid use of Pipe with the implementation of the PipeTransform interface', () => {
+        it(`should succeed when Pipe is declared properly`, () => {
+            let source = `
+                    @Pipe({name: 'fetch'})
+                    export class NewPipe  implements PipeTransform{
+                      transform(url:string):any {
+                      }
+                    }`;
+            assertSuccess('pipe-transform-interface', source);
+        });
+    });
+    describe('valid use of empty class', () => {
+        it(`should succeed, when Pipe is not used`, () => {
+            let source = `class App{}`;
+            assertSuccess('pipe-transform-interface', source);
+        });
+    });
+});
