add usePipeDecoratorRule, refactored linting erros, updated to rc5

package.json

@@ -44,8 +44,8 @@
   },
   "homepage": "https://github.com/mgechev/codelyzer#readme",
   "devDependencies": {
-    "@angular/compiler": "^4.0.0-rc.2",
-    "@angular/core": "^4.0.0-rc.2",
+    "@angular/compiler": "^4.0.0-rc.5",
+    "@angular/core": "^4.0.0-rc.5",
     "@types/chai": "^3.4.33",
     "@types/less": "0.0.31",
     "@types/mocha": "^2.2.32",

src/angular/styles/chars.ts

@@ -73,7 +73,7 @@ export const $AT = 64;
 export const $BT = 96;
 
 export function isWhitespace(code: number): boolean {
-  return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
+  return (code >= $TAB && code <= $SPACE) || (code === $NBSP);
 }
 
 export function isDigit(code: number): boolean {

src/angular/styles/parseUtil.ts

@@ -47,8 +47,8 @@ export abstract class ParseError {
       while (ctxLen < 100 && ctxStart > 0) {
         ctxStart--;
         ctxLen++;
-        if (source[ctxStart] == '\n') {
-          if (++ctxLines == 3) {
+        if (source[ctxStart] === '\n') {
+          if (++ctxLines === 3) {
             break;
           }
         }
@@ -59,8 +59,8 @@ export abstract class ParseError {
       while (ctxLen < 100 && ctxEnd < source.length - 1) {
         ctxEnd++;
         ctxLen++;
-        if (source[ctxEnd] == '\n') {
-          if (++ctxLines == 3) {
+        if (source[ctxEnd] === '\n') {
+          if (++ctxLines === 3) {
             break;
           }
         }

src/angular/templates/basicTemplateAstVisitor.ts

@@ -1,7 +1,7 @@
 import * as ast from '@angular/compiler';
 import * as ts from 'typescript';
 import * as Lint from 'tslint';
-import * as e from '@angular/compiler/typings/src/expression_parser/ast';
+import * as e from '@angular/compiler/src/expression_parser/ast';
 
 import { ExpTypes } from '../expressionTypes';
 import { ComponentMetadata } from '../metadata';

src/angular/templates/recursiveAngularExpressionVisitor.ts

@@ -1,6 +1,6 @@
 import * as Lint from 'tslint';
 import * as ts from 'typescript';
-import * as e from '@angular/compiler/typings/src/expression_parser/ast';
+import * as e from '@angular/compiler/src/expression_parser/ast';
 
 import {SourceMappingVisitor} from '../sourceMappingVisitor';
 import {ComponentMetadata} from '../metadata';

src/angular/templates/referenceCollectorVisitor.ts

@@ -39,7 +39,7 @@ export class ReferenceCollectorVisitor implements ast.TemplateAstVisitor {
     element.children.forEach(e => this.visit(e, context));
     this._variables = this._variables.concat(references);
   }
-  
+
   get variables() {
     return this._variables;
   }

src/angular/templates/templateParser.ts

@@ -2,8 +2,8 @@ import * as compiler from '@angular/compiler';
 
 import { Config, DirectiveDeclaration } from '../config';
 import { SemVerDSL } from '../../util/ngVersion';
-import { NO_ERRORS_SCHEMA } from "@angular/core";
-import { ɵConsole } from "@angular/core";
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import { ɵConsole } from '@angular/core';
 let refId = 0;
 
 const dummyMetadataFactory = (declaration: DirectiveDeclaration) => {
@@ -72,6 +72,7 @@ export const parseTemplate = (template: string, directives: DirectiveDeclaration
   const templateMetadata: compiler.CompileTemplateMetadata = {
     encapsulation: 0,
     template: template,
+    isInline: false,
     templateUrl: '',
     styles: [],
     styleUrls: [],

src/componentClassSuffixRule.ts

@@ -32,10 +32,6 @@ export class Rule extends Lint.Rules.AbstractRule {
 
     static FAILURE: string = 'The name of the class %s should end with the suffix %s ($$02-03$$)';
 
-    static validate(className: string, suffixList: string[]): boolean {
-        return suffixList.some(suffix => className.endsWith(suffix));
-    }
-
     static walkerBuilder: F2<ts.SourceFile, IOptions, Ng2Walker> =
         all(
             validateComponent((meta: ComponentMetadata, suffixList?: string[]) =>
@@ -50,6 +46,10 @@ export class Rule extends Lint.Rules.AbstractRule {
                     })
             ));
 
+    static validate(className: string, suffixList: string[]): boolean {
+      return suffixList.some(suffix => className.endsWith(suffix));
+    }
+
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
         return this.applyWithWalker(
             Rule.walkerBuilder(sourceFile, this.getOptions())

src/componentSelectorRule.ts

@@ -19,30 +19,30 @@ export class Rule extends SelectorRule {
     * It is easier to recognize that a symbol is a component by looking at the template's HTML.
     `,
     options: {
-      "type": "array",
-      "items": [
+      'type': 'array',
+      'items': [
         {
-          "enum": ["element", "attribute"]
+          'enum': ['element', 'attribute']
         },
         {
-          "oneOf": [
+          'oneOf': [
             {
-              "type": "array",
-              "items": {
-                "type": "string"
+              'type': 'array',
+              'items': {
+                'type': 'string'
               }
             },
             {
-              "type": "string"
+              'type': 'string'
             }
           ]
         },
         {
-          "enum": ["kebab-case", "camelCase"]
+          'enum': ['kebab-case', 'camelCase']
         }
       ],
-      "minItems": 3,
-      "maxItems": 3
+      'minItems': 3,
+      'maxItems': 3
     },
     optionExamples: [
       `["element", "my-prefix", "kebab-case"]`,

src/directiveSelectorRule.ts

@@ -16,30 +16,30 @@ export class Rule extends SelectorRule {
     * It is easier to recognize that a symbol is a directive by looking at the template's HTML.
     `,
     options: {
-      "type": "array",
-      "items": [
+      'type': 'array',
+      'items': [
         {
-          "enum": ["element", "attribute"]
+          'enum': ['element', 'attribute']
         },
         {
-          "oneOf": [
+          'oneOf': [
             {
-              "type": "array",
-              "items": {
-                "type": "string"
+              'type': 'array',
+              'items': {
+                'type': 'string'
               }
             },
             {
-              "type": "string"
+              'type': 'string'
             }
           ]
         },
         {
-          "enum": ["kebab-case", "camelCase"]
+          'enum': ['kebab-case', 'camelCase']
         }
       ],
-      "minItems": 3,
-      "maxItems": 3
+      'minItems': 3,
+      'maxItems': 3
     },
     optionExamples: [
       `["element", "my-prefix", "kebab-case"]`,

src/importDestructuringSpacingRule.ts

@@ -30,7 +30,7 @@ class ImportDestructuringSpacingWalker extends Lint.SkippableTokenAwareRuleWalke
 
   public visitImportDeclaration(node: ts.ImportDeclaration) {
     const importClause = node.importClause;
-    if (importClause != null && importClause.namedBindings != null) {
+    if (importClause !== null && importClause.namedBindings !== null) {
       const text = importClause.namedBindings.getText();
 
       if (!this.checkForWhiteSpace(text)) {

src/noAccessMissingMemberRule.ts

@@ -6,7 +6,7 @@ import {Ng2Walker} from './angular/ng2Walker';
 import {RecursiveAngularExpressionVisitor} from './angular/templates/recursiveAngularExpressionVisitor';
 import {ExpTypes} from './angular/expressionTypes';
 import {getDeclaredMethodNames, getDeclaredPropertyNames} from './util/classDeclarationUtils';
-import * as e from '@angular/compiler/typings/src/expression_parser/ast';
+import * as e from '@angular/compiler/src/expression_parser/ast';
 
 import {Config} from './angular/config';
 

src/noAttributeParameterDecoratorRule.ts

@@ -46,10 +46,10 @@ export class Rule extends Lint.Rules.AbstractRule {
                                 // We only care about 1 since we highlight the whole 'parameter'
                                 return decoratorsFailed.fmap(() =>
                                     new Failure(p, sprintf(Rule.FAILURE_STRING,
-                                        parentName, (<any>p.name).text, (<any>p.name).text)))
+                                        parentName, (<any>p.name).text, (<any>p.name).text)));
                             })
                     );
-                    return listToMaybe(failures)
+                    return listToMaybe(failures);
                 });
         })
     );

src/noUnusedCssRule.ts

@@ -133,7 +133,7 @@ class ElementFilterVisitor extends BasicTemplateAstVisitor {
       return !selectorTypes[s] || !strategy(ast);
     }) && (ast.children || [])
       .every(c => ast instanceof ElementAst && this.shouldVisit(<ElementAst>c, strategies, selectorTypes)
-                  || ast instanceof EmbeddedTemplateAst && 
+                  || ast instanceof EmbeddedTemplateAst &&
                   (ast.children || []).every(c => this.shouldVisit(<ElementAst>c, strategies, selectorTypes)));
   }
 }

src/pipeImpureRule.ts

@@ -38,7 +38,7 @@ export class ClassMetadataWalker extends Ng2Walker {
     let argument = this.extractArgument(pipe);
     if (argument.kind === SyntaxKind.current().ObjectLiteralExpression) {
       argument.properties.filter(n => n.name.text === 'pure')
-      .forEach(this.validateProperty.bind(this, className))
+      .forEach(this.validateProperty.bind(this, className));
     }
   }
 

src/pipeNamingRule.ts

@@ -12,12 +12,12 @@ export class Rule extends Lint.Rules.AbstractRule {
     description: `Enforce consistent case and prefix for pipes.`,
     rationale: `Consistent conventions make it easy to quickly identify and reference assets of different types.`,
     options: {
-      "type": "array",
-      "items": [
-        {"enum": ["kebab-case", "attribute"]},
-        {"type": "string"}
+      'type': 'array',
+      'items': [
+        {'enum': ['kebab-case', 'attribute']},
+        {'type': 'string'}
       ],
-      "minItems": 1
+      'minItems': 1
     },
     optionExamples: [
       `["camelCase", "myPrefix"]`,

src/templatesUsePublicRule.ts

@@ -4,7 +4,7 @@ import {stringDistance} from './util/utils';
 import {getDeclaredProperties, getDeclaredMethods} from './util/classDeclarationUtils';
 import {Ng2Walker} from './angular/ng2Walker';
 import {RecursiveAngularExpressionVisitor} from './angular/templates/recursiveAngularExpressionVisitor';
-import * as e from '@angular/compiler/typings/src/expression_parser/ast';
+import * as e from '@angular/compiler/src/expression_parser/ast';
 import SyntaxKind = require('./util/syntaxKind');
 
 enum DeclarationType {

src/useLifeCycleInterfaceRule.ts

@@ -55,7 +55,7 @@ export class ClassMetadataWalker extends Lint.RuleWalker {
         super.visitClassDeclaration(node);
     }
 
-    private extractInterfaces(node:ts.ClassDeclaration,syntaxKind:SyntaxKind.SyntaxKind):string[]{
+    private extractInterfaces(node:ts.ClassDeclaration,syntaxKind:SyntaxKind.SyntaxKind): string[] {
         let interfaces:string[] = [];
         if (node.heritageClauses) {
             let interfacesClause = node.heritageClauses.filter(h=>h.token === syntaxKind.ImplementsKeyword);
@@ -66,26 +66,26 @@ export class ClassMetadataWalker extends Lint.RuleWalker {
         return interfaces;
     }
 
-    private validateMethods( methods:any[],interfaces:string[],className:string){
-        methods.forEach(m => {
+    private validateMethods( methods: any[], interfaces: string[], className: string) {
+        methods.forEach( m => {
             let n = (<any>m.name).text;
-            if(n && this.isMethodValidHook(m,interfaces)){
+            if(n && this.isMethodValidHook(m, interfaces)) {
                 let hookName = n.substr(2, n.lenght);
                 this.addFailure(
                     this.createFailure(
                         m.name.getStart(),
                         m.name.getWidth(),
-                        sprintf.apply(this, [Rule.FAILURE, hookName,Rule.HOOKS_PREFIX + hookName, className])));
+                        sprintf.apply(this, [Rule.FAILURE, hookName, Rule.HOOKS_PREFIX + hookName, className])));
             }
         });
     }
 
-    private isMethodValidHook(m:any,interfaces:string[]):boolean{
+    private isMethodValidHook(m:any,interfaces:string[]): boolean {
         let n = (<any>m.name).text;
-        let isNg:boolean = n.substr(0, 2) === Rule.HOOKS_PREFIX;
+        let isNg: boolean = n.substr(0, 2) === Rule.HOOKS_PREFIX;
         let hookName = n.substr(2, n.lenght);
         let isHook = Rule.LIFE_CYCLE_HOOKS_NAMES.indexOf(hookName) !== -1;
-        let isNotIn:boolean = interfaces.indexOf(hookName) === -1;
+        let isNotIn: boolean = interfaces.indexOf(hookName) === -1;
         return isNg && isHook && isNotIn;
     }
 

src/usePipeDecoratorRule.ts

@@ -0,0 +1,66 @@
+import * as Lint from 'tslint';
+import * as ts from 'typescript';
+import {sprintf} from 'sprintf-js';
+import SyntaxKind = require('./util/syntaxKind');
+
+const getInterfaceName = (t: any) => {
+  if (t.expression && t.expression.name) {
+    return t.expression.name.text;
+  }
+  return t.expression.text;
+};
+
+export class Rule extends Lint.Rules.AbstractRule {
+  public static metadata: Lint.IRuleMetadata = {
+    ruleName: 'use-pipe-decorator',
+    type: 'maintainability',
+    description: `Ensure that classes implementing PipeTransform interface, use Pipe decorator`,
+    rationale: `Interfaces prescribe typed method signatures. Use those signatures to flag spelling and syntax mistakes.`,
+    options: null,
+    optionsDescription: `Not configurable.`,
+    typescriptOnly: true,
+  };
+
+
+  static FAILURE: string = 'The %s class implements the PipeTransform interface, so it should use the @Pipe decorator';
+  static PIPE_INTERFACE_NAME = 'PipeTransform';
+
+  public apply(sourceFile:ts.SourceFile):Lint.RuleFailure[] {
+    return this.applyWithWalker(
+      new ClassMetadataWalker(sourceFile,
+        this.getOptions()));
+  }
+}
+
+export class ClassMetadataWalker extends Lint.RuleWalker {
+
+  visitClassDeclaration(node:ts.ClassDeclaration) {
+    if (this.hasIPipeTransform(node)) {
+        let decorators =  <any[]>node.decorators || [];
+        let className:string = node.name.text;
+        let pipes:Array<string> = decorators.map(d =>
+        (<any>d.expression).text ||
+        ((<any>d.expression).expression || {}).text).filter( t=> t === 'Pipe');
+        if (pipes.length === 0) {
+         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(getInterfaceName);
+      }
+    }
+    return interfaces.indexOf(Rule.PIPE_INTERFACE_NAME) !== -1;
+  }
+}

src/usePipeTransformInterfaceRule.ts

@@ -41,7 +41,7 @@ export class ClassMetadataWalker extends Lint.RuleWalker {
           ((<any>d.expression).expression || {}).text).filter(t=> t === 'Pipe');
       if (pipes.length !== 0) {
         let className:string = node.name.text;
-        if(!this.hasIPipeTransform(node)){
+        if (!this.hasIPipeTransform(node)) {
           this.addFailure(
             this.createFailure(
               node.getStart(),
@@ -53,7 +53,7 @@ export class ClassMetadataWalker extends Lint.RuleWalker {
     super.visitClassDeclaration(node);
   }
 
-  private hasIPipeTransform(node:ts.ClassDeclaration):boolean{
+  private hasIPipeTransform(node:ts.ClassDeclaration): boolean {
     let interfaces = [];
     if (node.heritageClauses) {
       let interfacesClause = node.heritageClauses