Fixed #22 and other minor fixes

Author: buzinas

README.md

@@ -4,10 +4,14 @@
 
 You want to code in TypeScript but miss all the rules available in ESLint?
 
-Now you can combine both worlds by using this TSLint plugin.
+Now you can combine both worlds by using this TSLint plugin!
 
+*WARN: this project is still under development.*
 
-## Usage (it will be available only in v0.2.x)
+*You can see what see what rules were already migrated migrated [in the eslint_tsling.json file](https://github.com/buzinas/tslint-eslint-rules/blob/master/eslint_tslint.json)*
+
+
+## Usage [TODO](https://github.com/buzinas/tslint-eslint-rules/issues/23)
 
 Install from NPM to your Dev Dependencies
 
@@ -266,7 +270,7 @@ The following rules point out areas where you might have made mistakes.
     ]
     ```
 
-* [valid-typeof](http://eslint.org/docs/rules/valid-typeof) => valid-typeof (tslint-eslint-rules) [TODO](https://github.com/buzinas/tslint-eslint-rules/issues/22)
+* [valid-typeof](http://eslint.org/docs/rules/valid-typeof) => valid-typeof (tslint-eslint-rules)
   * Description: Ensure that the results of typeof are compared against a valid string (recommended)
   * Usage
 
@@ -2246,167 +2250,6 @@ The following rules are included for compatibility with [JSHint](http://jshint.c
       ]
     ```
 
-### Removed
-
-These rules existed in a previous version of ESLint but have since been replaced by newer rules.
-
-* [generator-star](http://eslint.org/docs/rules/generator-star) => 
-  * Description: enforce the position of the `*` in generator functions (replaced by [generator-star-spacing](http://eslint.org/docs/rules/generator-star-spacing))
-  * Usage
-
-    ```json
-    "generator-star": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [global-strict](http://eslint.org/docs/rules/global-strict) => 
-  * Description: require or disallow the `"use strict"` pragma in the global scope (replaced by [strict](http://eslint.org/docs/rules/strict))
-  * Usage
-
-    ```json
-    "global-strict": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [no-comma-dangle](http://eslint.org/docs/rules/no-comma-dangle) => 
-  * Description: disallow trailing commas in object literals (replaced by [comma-dangle](http://eslint.org/docs/rules/comma-dangle))
-  * Usage
-
-    ```json
-    "no-comma-dangle": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [no-empty-class](http://eslint.org/docs/rules/no-empty-class) => 
-  * Description: disallow the use of empty character classes in regular expressions (replaced by [no-empty-character-class](http://eslint.org/docs/rules/no-empty-character-class))
-  * Usage
-
-    ```json
-    "no-empty-class": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [no-extra-strict](http://eslint.org/docs/rules/no-extra-strict) => 
-  * Description: disallow unnecessary use of `"use strict";` when already in strict mode (replaced by [strict](http://eslint.org/docs/rules/strict))
-  * Usage
-
-    ```json
-    "no-extra-strict": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [no-reserved-keys](http://eslint.org/docs/rules/no-reserved-keys) => 
-  * Description: disallow reserved words being used as object literal keys
-  * Usage
-
-    ```json
-    "no-reserved-keys": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [no-space-before-semi](http://eslint.org/docs/rules/no-space-before-semi) => 
-  * Description: disallow space before semicolon (replaced by [semi-spacing](http://eslint.org/docs/rules/semi-spacing))
-  * Usage
-
-    ```json
-    "no-space-before-semi": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [no-wrap-func](http://eslint.org/docs/rules/no-wrap-func) => 
-  * Description: disallow wrapping of non-IIFE statements in parens (replaced by [no-extra-parens](http://eslint.org/docs/rules/no-extra-parens))
-  * Usage
-
-    ```json
-    "no-wrap-func": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [space-after-function-name](http://eslint.org/docs/rules/space-after-function-name) => 
-  * Description: require a space after function names (replaced by [space-before-function-paren](http://eslint.org/docs/rules/space-before-function-paren))
-  * Usage
-
-    ```json
-    "space-after-function-name": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [space-before-function-parentheses](http://eslint.org/docs/rules/space-before-function-parentheses) => 
-  * Description: require or disallow space before function parentheses (replaced by [space-before-function-paren](http://eslint.org/docs/rules/space-before-function-paren))
-  * Usage
-
-    ```json
-    "space-before-function-parentheses": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [space-in-brackets](http://eslint.org/docs/rules/space-in-brackets) => 
-  * Description: require or disallow spaces inside brackets (replaced by [object-curly-spacing](http://eslint.org/docs/rules/object-curly-spacing) and [array-bracket-spacing](http://eslint.org/docs/rules/array-bracket-spacing))
-  * Usage
-
-    ```json
-    "space-in-brackets": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [space-unary-word-ops](http://eslint.org/docs/rules/space-unary-word-ops) => 
-  * Description: require or disallow spaces before/after unary operators (replaced by [space-unary-ops](http://eslint.org/docs/rules/space-unary-ops))
-  * Usage
-
-    ```json
-    "space-unary-word-ops": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-* [spaced-line-comment](http://eslint.org/docs/rules/spaced-line-comment) => 
-  * Description: require or disallow a space immediately following the `//` in a line comment (replaced by [spaced-comment](spaced-comment))
-  * Usage
-
-    ```json
-    "spaced-line-comment": [
-        true,
-        {
-          
-        }
-      ]
-    ```
-
 
 ## Contributing
 

eslint_tslint.json

@@ -0,0 +1,7 @@
+{
+  "rulesDirectory": "dist/rules",
+  "rules": {
+    "no-constant-condition": true,
+    "valid-typeof": true
+  }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "tslint-eslint-rules",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Improve your TSLint with the missing ESLint Rules",
   "main": "index.js",
   "scripts": {

src/rules/noConstantConditionRule.ts

@@ -2,7 +2,7 @@
 /// <reference path='../../node_modules/tslint/lib/tslint.d.ts' />
 
 export class Rule extends Lint.Rules.AbstractRule {
-  public static FAILURE_STRING = "Unexpected constant condition: ";
+  public static FAILURE_STRING = 'Unexpected constant condition: ';
 
   public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
     const walker = new NoConstantConditionWalker(sourceFile, this.getOptions());
@@ -25,7 +25,7 @@ class NoConstantConditionWalker extends Lint.RuleWalker {
 
   protected visitDoStatement(node: ts.DoStatement) {
     this.validateConditionalExpression(node.expression);
-    super.visitWhileStatement(node);
+    super.visitDoStatement(node);
   }
 
   protected visitForStatement(node: ts.ForStatement) {
@@ -42,49 +42,49 @@ class NoConstantConditionWalker extends Lint.RuleWalker {
 
   private validateConditionalExpression(expression: ts.Expression) {
     this.isInConditional = true;
-    if (isConstant(expression)) {
+    if (this.isConstant(expression)) {
       this.addFailure(this.createFailure(expression.getStart(), expression.getWidth(), Rule.FAILURE_STRING));
     }
     // walk the children of the conditional expression for nested conditions
     this.walkChildren(expression);
     this.isInConditional = false;
   }
-}
-
-function isConstant(node: ts.Node) {
-  switch (node.kind) {
-    // ESLint Literal
-    case ts.SyntaxKind.StringLiteral:
-    case ts.SyntaxKind.NumericLiteral:
-    case ts.SyntaxKind.TrueKeyword:
-    case ts.SyntaxKind.FalseKeyword:
-    // ESLint ArrowFunctionExpression
-    case ts.SyntaxKind.ArrowFunction:
-    // ESLint FunctionExpression
-    case ts.SyntaxKind.FunctionExpression:
-    // ESLint ObjectExpression
-    case ts.SyntaxKind.ObjectLiteralExpression:
-    // ESLint ArrayExpression
-    case ts.SyntaxKind.ArrayLiteralExpression:
-      return true;
-    // ESLint UnaryExpression
-    case ts.SyntaxKind.PrefixUnaryExpression:
-    case ts.SyntaxKind.PostfixUnaryExpression:
-      return false; // TODO
-    // ESLint BinaryExpression / LogicalExpression
-    case ts.SyntaxKind.BinaryExpression:
-      // ESLint AssignmentExpression
-      if (isAssignmentToken((node as ts.BinaryExpression).operatorToken)) {
-        return isConstant(node.getLastToken());
-      }
-      return isConstant(node.getFirstToken()) && isConstant(node.getLastToken());
-    case ts.SyntaxKind.ConditionalExpression:
-      return isConstant((node as ts.ConditionalExpression).condition);
+  
+  private isConstant(node: ts.Node) {
+    switch (node.kind) {
+      // ESLint Literal
+      case ts.SyntaxKind.StringLiteral:
+      case ts.SyntaxKind.NumericLiteral:
+      case ts.SyntaxKind.TrueKeyword:
+      case ts.SyntaxKind.FalseKeyword:
+      // ESLint ArrowFunctionExpression
+      case ts.SyntaxKind.ArrowFunction:
+      // ESLint FunctionExpression
+      case ts.SyntaxKind.FunctionExpression:
+      // ESLint ObjectExpression
+      case ts.SyntaxKind.ObjectLiteralExpression:
+      // ESLint ArrayExpression
+      case ts.SyntaxKind.ArrayLiteralExpression:
+        return true;
+      // ESLint UnaryExpression
+      case ts.SyntaxKind.PrefixUnaryExpression:
+      case ts.SyntaxKind.PostfixUnaryExpression:
+        return false; // TODO
+      // ESLint BinaryExpression / LogicalExpression
+      case ts.SyntaxKind.BinaryExpression:
+        // ESLint AssignmentExpression
+        if (this.isAssignmentToken((node as ts.BinaryExpression).operatorToken)) {
+          return this.isConstant(node.getLastToken());
+        }
+        return this.isConstant(node.getFirstToken()) && this.isConstant(node.getLastToken());
+      case ts.SyntaxKind.ConditionalExpression:
+        return this.isConstant((node as ts.ConditionalExpression).condition);
+    }
+  
+    return false;
+  }
+  
+  private isAssignmentToken(token: ts.Node) {
+    return token.kind >= ts.SyntaxKind.FirstAssignment && token.kind <= ts.SyntaxKind.LastAssignment;
   }
-
-  return false;
-}
-
-function isAssignmentToken(token: ts.Node) {
-  return token.kind >= ts.SyntaxKind.FirstAssignment && token.kind <= ts.SyntaxKind.LastAssignment;
 }

src/rules/validTypeofRule.ts

@@ -0,0 +1,36 @@
+/// <reference path='../../node_modules/tslint/typings/typescriptServices.d.ts' />
+/// <reference path='../../node_modules/tslint/lib/tslint.d.ts' />
+
+export class Rule extends Lint.Rules.AbstractRule {
+  public static FAILURE_STRING = 'Invalid typeof comparison value: ';
+
+  public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+    const walker = new ValidTypeofWalker(sourceFile, this.getOptions());
+    return this.applyWithWalker(walker);
+  }
+}
+
+class ValidTypeofWalker extends Lint.RuleWalker {
+  private VALID_TYPES = ['symbol', 'undefined', 'object', 'boolean', 'number', 'string', 'function'];
+  private OPERATORS = [ts.SyntaxKind.EqualsEqualsToken, ts.SyntaxKind.EqualsEqualsEqualsToken, ts.SyntaxKind.ExclamationEqualsToken, ts.SyntaxKind.ExclamationEqualsEqualsToken];
+  
+  protected visitNode(node: ts.Node) {
+    if (node.kind === ts.SyntaxKind.TypeOfExpression) {
+      this.validateTypeOf(node as ts.TypeOfExpression);
+    }
+    super.visitNode(node);
+  }
+
+  private validateTypeOf(node: ts.TypeOfExpression) {
+    if (node.parent.kind === ts.SyntaxKind.BinaryExpression) {
+      let parent = (node.parent as ts.BinaryExpression);
+      if (this.OPERATORS.indexOf(parent.operatorToken.kind) !== -1) {
+        let sibling = parent.left === node ? parent.right : parent.left;
+        
+        if (sibling.kind === ts.SyntaxKind.StringLiteral && this.VALID_TYPES.indexOf((sibling as ts.StringLiteral).text) === -1) {
+          this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING));
+        }
+      }
+    }
+  }
+}

src/test/rules/validTypeofRuleTests.ts

@@ -0,0 +1,30 @@
+/// <reference path='../../../typings/chai/chai.d.ts' />
+/// <reference path='../../../typings/mocha/mocha.d.ts' />
+
+import {testScript} from './helper';
+import {expect} from 'chai';
+
+const rule = 'valid-typeof';
+const scripts = {
+  valid: `if (typeof foo === "string") {}
+          if (typeof bar == 'undefined') {}
+          if (typeof foo === baz) {}
+          if (typeof bar === typeof qux) {}`,
+
+  invalid: `if (typeof foo === "strnig") {}
+            if (typeof foo == "undefimed") {}
+            if (typeof bar != 'nunber') {}
+            if (typeof bar !== "fucntion") {}`
+};
+  
+describe('valid-oftype', function test() {
+  it('should pass when using valid strings or variables', function testValid() {
+    const res = testScript(rule, scripts.valid);
+    expect(res).to.be.true;
+  });
+  
+  it('should fail when using invalid strings', function testInvalid() {
+    const res = testScript(rule, scripts.invalid);
+    expect(res).to.be.false;
+  });
+});