fix(rules): add doc to utils and fix partial migration issue

mgechev · mgechev · commit cca31efb0beb · 2018-04-17T14:07:53.000-06:00
diff --git a/src/migrateStaticObservableMethodsRule.ts b/src/migrateStaticObservableMethodsRule.ts
@@ -1,13 +1,11 @@
-// Original author Bowen Ni
-// Modifications mgechev.
-
 import * as Lint from 'tslint';
 import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 import { subtractSets, concatSets, isObservable, returnsObservable, computeInsertionIndexForImports } from './utils';
+
 /**
- * A typed TSLint rule that inspects observable chains using patched RxJs
- * operators and turns them into a pipeable operator chain.
+ * A typed TSLint rule that inspects observable
+ * static methods and turns them into function calls.
  */
 export class Rule extends Lint.Rules.TypedRule {
   static metadata: Lint.IRuleMetadata = {
@@ -30,7 +28,9 @@ export class Rule extends Lint.Rules.TypedRule {
     const sourceFile = ctx.sourceFile;
     const typeChecker = program.getTypeChecker();
     const insertionStart = computeInsertionIndexForImports(sourceFile);
-    let rxjsOperatorImports = findImportedRxjsOperators(sourceFile);
+    let rxjsOperatorImports = new Set<OperatorWithAlias>(
+      Array.from(findImportedRxjsOperators(sourceFile)).map(o => OPERATOR_WITH_ALIAS_MAP[o])
+    );
 
     function checkPatchableOperatorUsage(node: ts.Node) {
       if (!isRxjsStaticOperatorCallExpression(node, typeChecker)) {
@@ -47,7 +47,7 @@ export class Rule extends Lint.Rules.TypedRule {
       const operatorName = OPERATOR_RENAMES[name] || name;
       const start = propAccess.getStart(sourceFile);
       const end = propAccess.getEnd();
-      const operatorsToImport = new Set<string>([operatorName]);
+      const operatorsToImport = new Set<OperatorWithAlias>([OPERATOR_WITH_ALIAS_MAP[operatorName]]);
       const operatorsToAdd = subtractSets(operatorsToImport, rxjsOperatorImports);
       const imports = createImportReplacements(operatorsToAdd, insertionStart);
       rxjsOperatorImports = concatSets(rxjsOperatorImports, operatorsToAdd);
@@ -137,9 +137,9 @@ function operatorAlias(operator: string) {
   return 'observable' + operator[0].toUpperCase() + operator.substring(1, operator.length);
 }
 
-function createImportReplacements(operatorsToAdd: Set<string>, startIndex: number): Lint.Replacement[] {
-  return [...Array.from(operatorsToAdd.values())].map(operator =>
-    Lint.Replacement.appendText(startIndex, `\nimport {${operator} as ${operatorAlias(operator)}} from 'rxjs';\n`)
+function createImportReplacements(operatorsToAdd: Set<OperatorWithAlias>, startIndex: number): Lint.Replacement[] {
+  return [...Array.from(operatorsToAdd.values())].map(tuple =>
+    Lint.Replacement.appendText(startIndex, `\nimport {${tuple.operator} as ${tuple.alias}} from 'rxjs';\n`)
   );
 }
 
@@ -180,3 +180,15 @@ const OPERATOR_RENAMES: { [key: string]: string } = {
   if: 'iif',
   fromPromise: 'from'
 };
+
+type OperatorWithAlias = { operator: string; alias: string };
+type OperatorWithAliasMap = { [key: string]: OperatorWithAlias };
+
+const OPERATOR_WITH_ALIAS_MAP: OperatorWithAliasMap = Array.from(RXJS_OPERATORS).reduce((a, o) => {
+  const operatorName = OPERATOR_RENAMES[o] || o;
+  a[operatorName] = {
+    operator: operatorName,
+    alias: operatorAlias(operatorName)
+  };
+  return a;
+}, {});
diff --git a/src/utils.ts b/src/utils.ts
@@ -1,14 +1,24 @@
 import * as ts from 'typescript';
 import * as tsutils from 'tsutils';
 
+/**
+ * Returns a new Set that contains elements present in the {@link source} but
+ * not present in {@link target}
+ */
 export function subtractSets<T>(source: Set<T>, target: Set<T>): Set<T> {
   return new Set([...Array.from(source.values())].filter(x => !target.has(x)));
 }
 
+/**
+ * Returns a new Set that contains union of the two input sets.
+ */
 export function concatSets<T>(set1: Set<T>, set2: Set<T>): Set<T> {
   return new Set([...Array.from(set1.values()), ...Array.from(set2.values())]);
 }
 
+/**
+ * Returns true if the {@link type} is an Observable or one of its sub-classes.
+ */
 export function isObservable(type: ts.Type, tc: ts.TypeChecker): boolean {
   if (tsutils.isTypeReference(type)) {
     type = type.target;
@@ -32,6 +42,10 @@ export function returnsObservable(node: ts.CallLikeExpression, tc: ts.TypeChecke
   return isObservable(returnType, tc);
 }
 
+/**
+ * Returns the index to be used for inserting import statements potentially
+ * after a leading file overview comment (separated from the file with \n\n).
+ */
 export function computeInsertionIndexForImports(sourceFile: ts.SourceFile): number {
   const comments = ts.getLeadingCommentRanges(sourceFile.getFullText(), 0) || [];
   if (comments.length > 0) {
