Merge pull request #19 from mgechev/pipe-name-rule

add pipe naming rule update README

Author: mgechev

README.md

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

src/pipeNamingRule.ts

@@ -0,0 +1,97 @@
+import * as Lint from 'tslint/lib/lint';
+import * as ts from 'typescript';
+import {sprintf} from 'sprintf-js';
+import SyntaxKind = require('./util/syntaxKind');
+import {SelectorValidator} from "./util/selectorValidator";
+
+export class Rule extends Lint.Rules.AbstractRule {
+
+
+    public prefix:string;
+    public hasPrefix:boolean;
+    private prefixChecker:Function;
+    private validator:Function;
+
+    constructor(ruleName:string, value:any, disabledIntervals:Lint.IDisabledInterval[]) {
+        super(ruleName, value, disabledIntervals);
+        if (value[1] === 'kebab-case') {
+            this.validator = SelectorValidator.kebabCase;
+        }
+        if (value[2]) {
+            this.hasPrefix = true;
+            this.prefix = value[2];
+            this.prefixChecker = SelectorValidator.prefix(value[2]);
+        }
+    }
+
+    public apply(sourceFile:ts.SourceFile):Lint.RuleFailure[] {
+        return this.applyWithWalker(
+            new ClassMetadataWalker(sourceFile, this));
+    }
+
+    public validateName(name:string):boolean {
+        return this.validator(name);
+    }
+
+    public validatePrefix(prefix:string):boolean {
+        return this.prefixChecker(prefix);
+    }
+
+    static  FAILURE_WITHOUT_PREFIX:string = 'The name of the Pipe decorator of class %s should' +
+        ' be named kebab-case, however its value is "%s".';
+
+    static  FAILURE_WITH_PREFIX:string = 'The name of the Pipe decorator of class %s should' +
+        ' be named kebab-case with prefix %s, however its value is "%s".';
+}
+
+export class ClassMetadataWalker extends Lint.RuleWalker {
+
+    constructor(sourceFile:ts.SourceFile, private rule:Rule) {
+        super(sourceFile, rule.getOptions());
+    }
+
+    visitClassDeclaration(node:ts.ClassDeclaration) {
+        let className = node.name.text;
+        let decorators = node.decorators || [];
+        decorators.filter(d=> {
+            let baseExpr = <any>d.expression || {};
+            return baseExpr.expression.text === 'Pipe'
+        }).forEach(this.validateProperties.bind(this, className));
+        super.visitClassDeclaration(node);
+    }
+
+    private validateProperties(className:string, pipe:any) {
+        let argument = this.extractArgument(pipe);
+        if (argument.kind === SyntaxKind.current().ObjectLiteralExpression) {
+            argument.properties.filter(n=>n.name.text === 'name')
+                .forEach(this.validateProperty.bind(this, className))
+        }
+    }
+
+    private extractArgument(pipe:any) {
+        let baseExpr = <any>pipe.expression || {};
+        let args = baseExpr.arguments || [];
+        return args[0];
+    }
+
+    private validateProperty(className:string, property:any) {
+        let propName:string = property.initializer.text;
+        let isValidName:boolean = this.rule.validateName(propName);
+        let isValidPrefix:boolean = (this.rule.hasPrefix?this.rule.validatePrefix(propName):true);
+        if (!isValidName || !isValidPrefix) {
+            this.addFailure(
+                this.createFailure(
+                    property.getStart(),
+                    property.getWidth(),
+                    sprintf.apply(this, this.createFailureArray(className, propName))));
+        }
+    }
+
+    private createFailureArray(className:string, pipeName:string):Array<string> {
+        if (this.rule.hasPrefix) {
+            return [Rule.FAILURE_WITH_PREFIX, className, this.rule.prefix, pipeName];
+        }
+        return [Rule.FAILURE_WITHOUT_PREFIX, className, pipeName];
+    }
+
+}

src/pipeTransformInterfaceRule.ts

@@ -12,8 +12,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 
     static  FAILURE:string = 'The %s class has the Pipe decorator, so it should implement the PipeTransform interface';
-
-    static  PIPE_INTERFACE_NAME = 'PipeTransform';
+    static  PIPE_INTERFACE_NAME='PipeTransform';
 }
 
 export class ClassMetadataWalker extends Lint.RuleWalker {
@@ -24,28 +23,27 @@ export class ClassMetadataWalker extends Lint.RuleWalker {
             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)) {
+                if(!this.hasIPipeTransform(node)){
                     this.addFailure(
                         this.createFailure(
                             node.getStart(),
                             node.getWidth(),
-                            sprintf.apply(this, [Rule.FAILURE, className])));
+                            sprintf.apply(this, [Rule.FAILURE,className])));
                 }
             }
         }
         super.visitClassDeclaration(node);
     }
 
-    private hasIPipeTransform(node:ts.ClassDeclaration):boolean {
+    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);
+                interfaces = interfacesClause[0].types.map(t=>(<any>t.expression).text);
             }
         }
-        return interfaces.indexOf(Rule.PIPE_INTERFACE_NAME) !== -1;
+        return interfaces.indexOf(Rule.PIPE_INTERFACE_NAME)!==-1;
     }
 }

test/pipeNamingRule.spec.ts

@@ -0,0 +1,71 @@
+import {assertFailure, assertSuccess} from './testHelper';
+
+describe('pipe-naming', () => {
+    describe('invalid pipe name', () => {
+        it('should fail when Pipe is named camelCase with prefix ng', () => {
+            let source = `
+                      @Pipe({
+                        name: 'fooBar'
+                      })
+                      class Test {}`;
+            assertFailure('pipe-naming', source, {
+                message: 'The name of the Pipe decorator of class Test should be named kebab-case with prefix ng, however its value is "fooBar".',
+                startPosition: {
+                    line: 2,
+                    character: 24
+                },
+                endPosition: {
+                    line: 2,
+                    character: 38
+                }
+            }, ['kebab-case','ng']);
+        });
+    });
+    describe('invalid pipe name', () => {
+        it('should fail when Pipe is named camelCase without prefix', () => {
+            let source = `
+                      @Pipe({
+                        name: 'fooBar'
+                      })
+                      class Test {}`;
+            assertFailure('pipe-naming', source, {
+                message: 'The name of the Pipe decorator of class Test should be named kebab-case, however its value is "fooBar".',
+                startPosition: {
+                    line: 2,
+                    character: 24
+                },
+                endPosition: {
+                    line: 2,
+                    character: 38
+                }
+            }, 'kebab-case');
+        });
+    });
+    describe('valid pipe name', () => {
+        it('should succeed when set valid name with prefix ng in @Pipe', () => {
+            let source = `
+                    @Pipe({
+                    name: 'ng-bar-foo'
+                    })
+                    class Test {}`;
+            assertSuccess('pipe-naming', source, ['kebab-case','ng']);
+        });
+    });
+    describe('valid pipe name', () => {
+        it('should succeed when set valid name in @Pipe', () => {
+            let source = `
+                    @Pipe({
+                    name: 'bar-foo'
+                    })
+                    class Test {}`;
+            assertSuccess('pipe-naming', source, ['kebab-case']);
+        });
+    });
+    describe('valid empty class', () => {
+        it('should succeed when the class is not a Pipe', () => {
+            let source = `
+                    class Test {}`;
+            assertSuccess('pipe-naming', source, ['kebab-case']);
+        });
+    });
+});