add pipe transform interfaces rule; fix forgoten call to super method in life cycle hooks and updated README

Author: PreskoIsTheGreatest

README.md

@@ -21,7 +21,8 @@ Below you can find a recommended configuration which is based on the [Angular 2
   "input-property-directive": true,
   "output-property-directive": true,
   "call-forward-ref":true,
-  "life-cycle-hook":true
+  "life-cycle-hook":true,
+  "pipe-transform-interface":true
 }
 ```
 
@@ -56,7 +57,7 @@ Below you can find a recommended configuration which is based on the [Angular 2
 - [ ] Rise warning on complex logic inside of the templates.
 - [ ] Do not manipulate elements referenced within the template.
 - [x] Implement life-cycle hooks explicitly.
-- [ ] Implement Pipe transform interface for pipes.
+- [x] Implement Pipe transform interface for pipes.
 - [ ] Proper naming for pipes (kebab-case, optionally prefixed).
 
 ## License

src/lifeCycleHookRule.ts

@@ -55,6 +55,7 @@ export class ClassMetadataWalker extends Lint.RuleWalker {
                     node.getWidth(),
                     sprintf.apply(this, this.formatFailure(className, missing))));
         }
+        super.visitClassDeclaration(node);
     }
 
 

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;
+    }
+}

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);
+        });
+    });
+});