3 files changed, 59 insertions, 59 deletions

diff --git a/packages/tslint-config/rules/asyncSuffixRule.ts b/packages/tslint-config/rules/asyncSuffixRule.ts
index 8af9d88d4..5215c7151 100644
--- a/packages/tslint-config/rules/asyncSuffixRule.ts
+++ b/packages/tslint-config/rules/asyncSuffixRule.ts
@@ -4,7 +4,7 @@ import * as ts from 'typescript';
 import { AsyncSuffixWalker } from './walkers/async_suffix';
 
 export class Rule extends Lint.Rules.AbstractRule {
-	public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-		return this.applyWithWalker(new AsyncSuffixWalker(sourceFile, this.getOptions()));
-	}
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new AsyncSuffixWalker(sourceFile, this.getOptions()));
+    }
 }
diff --git a/packages/tslint-config/rules/underscorePrivatesRule.ts b/packages/tslint-config/rules/underscorePrivatesRule.ts
index 4d9ee69f7..472ea09ff 100644
--- a/packages/tslint-config/rules/underscorePrivatesRule.ts
+++ b/packages/tslint-config/rules/underscorePrivatesRule.ts
@@ -4,58 +4,58 @@ import * as ts from 'typescript';
 const UNDERSCORE = '_';
 
 type RelevantClassMember =
-	| ts.MethodDeclaration
-	| ts.PropertyDeclaration
-	| ts.GetAccessorDeclaration
-	| ts.SetAccessorDeclaration;
+    | ts.MethodDeclaration
+    | ts.PropertyDeclaration
+    | ts.GetAccessorDeclaration
+    | ts.SetAccessorDeclaration;
 
 // Copied from: https://github.com/DanielRosenwasser/underscore-privates-tslint-rule
 // The version on github is not published on npm
 export class Rule extends Lint.Rules.AbstractRule {
-	public static FAILURE_STRING = 'private members must be prefixed with an underscore';
+    public static FAILURE_STRING = 'private members must be prefixed with an underscore';
 
-	public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-		return this.applyWithFunction(sourceFile, walk);
-	}
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithFunction(sourceFile, walk);
+    }
 }
 function walk(ctx: Lint.WalkContext<void>): void {
-	traverse(ctx.sourceFile);
+    traverse(ctx.sourceFile);
 
-	function traverse(node: ts.Node): void {
-		checkNodeForViolations(ctx, node);
-		return ts.forEachChild(node, traverse);
-	}
+    function traverse(node: ts.Node): void {
+        checkNodeForViolations(ctx, node);
+        return ts.forEachChild(node, traverse);
+    }
 }
 function checkNodeForViolations(ctx: Lint.WalkContext<void>, node: ts.Node): void {
-	if (!isRelevantClassMember(node)) {
-		return;
-	}
-	// The declaration might have a computed property name or a numeric name.
-	const name = node.name;
-	if (!nameIsIdentifier(name)) {
-		return;
-	}
-	if (!nameStartsWithUnderscore(name.text) && memberIsPrivate(node)) {
-		ctx.addFailureAtNode(name, Rule.FAILURE_STRING);
-	}
+    if (!isRelevantClassMember(node)) {
+        return;
+    }
+    // The declaration might have a computed property name or a numeric name.
+    const name = node.name;
+    if (!nameIsIdentifier(name)) {
+        return;
+    }
+    if (!nameStartsWithUnderscore(name.text) && memberIsPrivate(node)) {
+        ctx.addFailureAtNode(name, Rule.FAILURE_STRING);
+    }
 }
 function isRelevantClassMember(node: ts.Node): node is RelevantClassMember {
-	switch (node.kind) {
-		case ts.SyntaxKind.MethodDeclaration:
-		case ts.SyntaxKind.PropertyDeclaration:
-		case ts.SyntaxKind.GetAccessor:
-		case ts.SyntaxKind.SetAccessor:
-			return true;
-		default:
-			return false;
-	}
+    switch (node.kind) {
+        case ts.SyntaxKind.MethodDeclaration:
+        case ts.SyntaxKind.PropertyDeclaration:
+        case ts.SyntaxKind.GetAccessor:
+        case ts.SyntaxKind.SetAccessor:
+            return true;
+        default:
+            return false;
+    }
 }
 function nameStartsWithUnderscore(text: string) {
-	return text.charCodeAt(0) === UNDERSCORE.charCodeAt(0);
+    return text.charCodeAt(0) === UNDERSCORE.charCodeAt(0);
 }
 function memberIsPrivate(node: ts.Declaration) {
-	return Lint.hasModifier(node.modifiers, ts.SyntaxKind.PrivateKeyword);
+    return Lint.hasModifier(node.modifiers, ts.SyntaxKind.PrivateKeyword);
 }
 function nameIsIdentifier(node: ts.Node): node is ts.Identifier {
-	return node.kind === ts.SyntaxKind.Identifier;
+    return node.kind === ts.SyntaxKind.Identifier;
 }
diff --git a/packages/tslint-config/rules/walkers/async_suffix.ts b/packages/tslint-config/rules/walkers/async_suffix.ts
index e1138de8d..eaec9c5f6 100644
--- a/packages/tslint-config/rules/walkers/async_suffix.ts
+++ b/packages/tslint-config/rules/walkers/async_suffix.ts
@@ -3,24 +3,24 @@ import * as Lint from 'tslint';
 import * as ts from 'typescript';
 
 export class AsyncSuffixWalker extends Lint.RuleWalker {
-	public static FAILURE_STRING = 'async functions must have an Async suffix';
-	public visitMethodDeclaration(node: ts.MethodDeclaration): void {
-		const methodNameNode = node.name;
-		const methodName = methodNameNode.getText();
-		if (!_.isUndefined(node.type)) {
-			if (node.type.kind === ts.SyntaxKind.TypeReference) {
-				// tslint:disable-next-line:no-unnecessary-type-assertion
-				const returnTypeName = (node.type as ts.TypeReferenceNode).typeName.getText();
-				if (returnTypeName === 'Promise' && !methodName.endsWith('Async')) {
-					const failure = this.createFailure(
-						methodNameNode.getStart(),
-						methodNameNode.getWidth(),
-						AsyncSuffixWalker.FAILURE_STRING,
-					);
-					this.addFailure(failure);
-				}
-			}
-		}
-		super.visitMethodDeclaration(node);
-	}
+    public static FAILURE_STRING = 'async functions must have an Async suffix';
+    public visitMethodDeclaration(node: ts.MethodDeclaration): void {
+        const methodNameNode = node.name;
+        const methodName = methodNameNode.getText();
+        if (!_.isUndefined(node.type)) {
+            if (node.type.kind === ts.SyntaxKind.TypeReference) {
+                // tslint:disable-next-line:no-unnecessary-type-assertion
+                const returnTypeName = (node.type as ts.TypeReferenceNode).typeName.getText();
+                if (returnTypeName === 'Promise' && !methodName.endsWith('Async')) {
+                    const failure = this.createFailure(
+                        methodNameNode.getStart(),
+                        methodNameNode.getWidth(),
+                        AsyncSuffixWalker.FAILURE_STRING,
+                    );
+                    this.addFailure(failure);
+                }
+            }
+        }
+        super.visitMethodDeclaration(node);
+    }
 }