refactor: Update rxjs operators to be lettable

Author: Brocco

bin/devkit-admin

@@ -34,10 +34,10 @@ process.chdir(path.join(__dirname, '..'));
 let logger = null;
 try {
   logger = new (require('@angular-devkit/core').logging.IndentLogger)('root');
-  require('rxjs/add/operator/filter');
+  const filter = require('rxjs/operators').filter;
 
   logger
-    .filter(entry => (entry.level !== 'debug' || args.verbose))
+    .pipe(filter(entry => (entry.level !== 'debug' || args.verbose)))
     .subscribe(entry => {
       let color = gray;
       let output = process.stdout;
@@ -52,7 +52,7 @@ try {
     });
 
   logger
-    .filter(entry => entry.level === 'fatal')
+    .pipe(filter(entry => entry.level === 'fatal'))
     .subscribe(() => {
       process.stderr.write('A fatal error happened. See details above.\n');
       process.exit(100);

package-lock.json

@@ -67,7 +67,7 @@
     "npm": "^5.2.0",
     "npm-run": "^4.1.2",
     "npm-run-all": "^4.0.0",
-    "rxjs": "^5.5.2",
+    "rxjs": "^5.5.6",
     "semver": "^5.3.0",
     "semver-intersect": "^1.1.2",
     "source-map": "^0.5.6",

package.json

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { logging, terminal } from '@angular-devkit/core';
-import 'rxjs/add/operator/filter';
+import { filter } from 'rxjs/operators';
 
 
 /**
@@ -16,7 +16,7 @@ export function createConsoleLogger(verbose = false): logging.Logger {
   const logger = new logging.IndentLogger('cling');
 
   logger
-    .filter(entry => (entry.level != 'debug' || verbose))
+    .pipe(filter(entry => (entry.level != 'debug' || verbose)))
     .subscribe(entry => {
       let color: (s: string) => string = x => terminal.dim(terminal.white(x));
       let output = process.stdout;

packages/angular_devkit/core/node/cli-logger.ts

@@ -18,8 +18,9 @@ import {
 } from '@angular-devkit/core';
 import * as fs from 'fs';
 import { Observable } from 'rxjs/Observable';
-import { ArrayObservable } from 'rxjs/observable/ArrayObservable';
-import { FromObservable } from 'rxjs/observable/FromObservable';
+import { empty } from 'rxjs/observable/empty';
+import { from as observableFrom } from 'rxjs/observable/from';
+import { of as observableOf } from 'rxjs/observable/of';
 import { concat } from 'rxjs/operators/concat';
 import { concatMap } from 'rxjs/operators/concatMap';
 import { ignoreElements } from 'rxjs/operators/ignoreElements';
@@ -131,11 +132,11 @@ export class NodeJsAsyncHost implements virtualFs.Host<fs.Stats> {
           };
           _recurseList(path);
 
-          return FromObservable.create(allFiles)
+          return observableFrom(allFiles)
             .pipe(
               mergeMap(p => _callFs(fs.unlink, this._getSystemPath(p))),
               ignoreElements(),
-              concat(FromObservable.create(allDirs).pipe(
+              concat(observableFrom(allDirs).pipe(
                 concatMap(p => _callFs(fs.rmdir, this._getSystemPath(p))),
               )),
               map(() => {}),
@@ -251,13 +252,13 @@ export class NodeJsSyncHost implements virtualFs.Host<fs.Stats> {
     _createDir(dirname(path));
     fs.writeFileSync(this._getSystemPath(path), new Uint8Array(content));
 
-    return Observable.empty<void>();
+    return empty<void>();
   }
 
   read(path: Path): Observable<virtualFs.FileBuffer> {
     const buffer = fs.readFileSync(this._getSystemPath(path));
 
-    return ArrayObservable.of(new Uint8Array(buffer).buffer as virtualFs.FileBuffer);
+    return observableOf(new Uint8Array(buffer).buffer as virtualFs.FileBuffer);
   }
 
   delete(path: Path): Observable<void> {
@@ -271,37 +272,37 @@ export class NodeJsSyncHost implements virtualFs.Host<fs.Stats> {
       fs.unlinkSync(this._getSystemPath(path));
     }
 
-    return Observable.empty();
+    return empty();
   }
 
   rename(from: Path, to: Path): Observable<void> {
     fs.renameSync(this._getSystemPath(from), this._getSystemPath(to));
 
-    return Observable.empty();
+    return empty();
   }
 
   list(path: Path): Observable<PathFragment[]> {
-    return ArrayObservable.of(fs.readdirSync(this._getSystemPath(path))).pipe(
+    return observableOf(fs.readdirSync(this._getSystemPath(path))).pipe(
       map(names => names.map(name => fragment(name))),
     );
   }
 
   exists(path: Path): Observable<boolean> {
-    return ArrayObservable.of(fs.existsSync(this._getSystemPath(path)));
+    return observableOf(fs.existsSync(this._getSystemPath(path)));
   }
 
   isDirectory(path: Path): Observable<boolean> {
     // tslint:disable-next-line:non-null-operator
-    return this.stats(path) !.map(stat => stat.isDirectory());
+    return this.stats(path) !.pipe(map(stat => stat.isDirectory()));
   }
   isFile(path: Path): Observable<boolean> {
     // tslint:disable-next-line:non-null-operator
-    return this.stats(path) !.map(stat => stat.isFile());
+    return this.stats(path) !.pipe(map(stat => stat.isFile()));
   }
 
   // Some hosts may not support stats.
   stats(path: Path): Observable<virtualFs.Stats<fs.Stats>> | null {
-    return ArrayObservable.of(fs.statSync(this._getSystemPath(path)));
+    return observableOf(fs.statSync(this._getSystemPath(path)));
   }
 
   // Some hosts may not support watching.

packages/angular_devkit/core/node/host.ts

@@ -8,8 +8,8 @@
 import * as ajv from 'ajv';
 import * as http from 'http';
 import { Observable } from 'rxjs/Observable';
-import 'rxjs/add/observable/of';
 import { fromPromise } from 'rxjs/observable/fromPromise';
+import { of as observableOf } from 'rxjs/observable/of';
 import { map } from 'rxjs/operators/map';
 import { JsonArray, JsonObject } from '../interface';
 import {
@@ -237,7 +237,7 @@ export class CoreSchemaRegistry implements SchemaRegistry {
     let validator: Observable<ajv.ValidateFunction>;
     try {
       const maybeFnValidate = this._ajv.compile(schema);
-      validator = Observable.of(maybeFnValidate);
+      validator = observableOf(maybeFnValidate);
     } catch (e) {
       // Propagate the error.
       if (!(e instanceof (ajv.MissingRefError as {} as Function))) {
@@ -261,7 +261,7 @@ export class CoreSchemaRegistry implements SchemaRegistry {
         map(validate => (data: any): Observable<SchemaValidatorResult> => {
           const result = validate(data);
           const resultObs = typeof result == 'boolean'
-            ? Observable.of(result)
+            ? observableOf(result)
             : fromPromise(result as PromiseLike<boolean>);
 
           return resultObs

packages/angular_devkit/core/src/json/schema/registry.ts

@@ -5,8 +5,8 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { Observable } from 'rxjs/Observable';
-import 'rxjs/add/operator/mergeMap';
+import { of as observableOf } from 'rxjs/observable/of';
+import { map, mergeMap } from 'rxjs/operators';
 import { CoreSchemaRegistry } from './registry';
 
 
@@ -31,12 +31,14 @@ describe('CoreSchemaRegistry', () => {
           },
         },
       })
-      .mergeMap(validator => validator(data))
-      .map(result => {
-        expect(result.success).toBe(true);
-        expect(data.obj.num).toBeUndefined();
-        expect(data.tslint).not.toBeUndefined();
-      })
+      .pipe(
+        mergeMap(validator => validator(data)),
+        map(result => {
+          expect(result.success).toBe(true);
+          expect(data.obj.num).toBeUndefined();
+          expect(data.tslint).not.toBeUndefined();
+        }),
+      )
       .subscribe(done, done.fail);
   });
 
@@ -61,11 +63,13 @@ describe('CoreSchemaRegistry', () => {
           },
         },
       })
-      .mergeMap(validator => validator(data))
-      .map(result => {
-        expect(result.success).toBe(true);
-        expect(data.obj.num).toBeUndefined();
-      })
+      .pipe(
+        mergeMap(validator => validator(data)),
+        map(result => {
+          expect(result.success).toBe(true);
+          expect(data.obj.num).toBeUndefined();
+        }),
+      )
       .subscribe(() => {
         isDone = true;
       }, done.fail);
@@ -93,10 +97,12 @@ describe('CoreSchemaRegistry', () => {
           str: { type: 'string', format: 'is-hotdog' },
         },
       })
-      .mergeMap(validator => validator(data))
-      .map(result => {
-        expect(result.success).toBe(true);
-      })
+      .pipe(
+        mergeMap(validator => validator(data)),
+        map(result => {
+          expect(result.success).toBe(true);
+        }),
+      )
       .subscribe(done, done.fail);
   });
 
@@ -107,7 +113,7 @@ describe('CoreSchemaRegistry', () => {
       name: 'is-hotdog',
       formatter: {
         async: true,
-        validate: (str: string) => Observable.of(str === 'hotdog'),
+        validate: (str: string) => observableOf(str === 'hotdog'),
       },
     };
 
@@ -120,10 +126,12 @@ describe('CoreSchemaRegistry', () => {
           str: { type: 'string', format: 'is-hotdog' },
         },
       })
-      .mergeMap(validator => validator(data))
-      .map(result => {
-        expect(result.success).toBe(true);
-      })
+      .pipe(
+        mergeMap(validator => validator(data)),
+        map(result => {
+          expect(result.success).toBe(true);
+        }),
+      )
       .subscribe(done, done.fail);
   });
 
@@ -147,11 +155,13 @@ describe('CoreSchemaRegistry', () => {
           banana: { type: 'string', format: 'is-hotdog' },
         },
       })
-      .mergeMap(validator => validator(data))
-      .map(result => {
-        expect(result.success).toBe(false);
-        expect(result.errors && result.errors[0]).toBe('.banana should match format "is-hotdog"');
-      })
+      .pipe(
+        mergeMap(validator => validator(data)),
+        map(result => {
+          expect(result.success).toBe(false);
+          expect(result.errors && result.errors[0]).toBe('.banana should match format "is-hotdog"');
+        }),
+      )
       .subscribe(done, done.fail);
   });
 });

packages/angular_devkit/core/src/json/schema/registry_spec.ts

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import 'rxjs/add/operator/map';
+import { map } from 'rxjs/operators';
 import { Logger } from './logger';
 
 
@@ -24,21 +24,21 @@ export class IndentLogger extends Logger {
     super(name, parent);
 
     indentationMap[indentation] = indentationMap[indentation] || [''];
-    const map = indentationMap[indentation];
+    const indentMap = indentationMap[indentation];
 
-    this._observable = this._observable.map(entry => {
+    this._observable = this._observable.pipe(map(entry => {
       const l = entry.path.length;
-      if (l >= map.length) {
-        let current = map[map.length - 1];
-        while (l >= map.length) {
+      if (l >= indentMap.length) {
+        let current = indentMap[indentMap.length - 1];
+        while (l >= indentMap.length) {
           current += indentation;
-          map.push(current);
+          indentMap.push(current);
         }
       }
 
-      entry.message = map[l] + entry.message.split(/\n/).join('\n' + map[l]);
+      entry.message = indentMap[l] + entry.message.split(/\n/).join('\n' + indentMap[l]);
 
       return entry;
-    });
+    }));
   }
 }

packages/angular_devkit/core/src/logger/indent.ts

@@ -6,15 +6,15 @@
  * found in the LICENSE file at https://angular.io/license
  */
 // tslint:disable:no-any
+import { toArray } from 'rxjs/operators';
 import { IndentLogger } from './indent';
 import { LogEntry, Logger } from './logger';
 
 
 describe('IndentSpec', () => {
   it('works', (done: DoneFn) => {
     const logger = new IndentLogger('test');
-    logger
-      .toArray()
+    logger.pipe(toArray())
       .toPromise()
       .then((observed: LogEntry[]) => {
         expect(observed).toEqual([

packages/angular_devkit/core/src/logger/indent_spec.ts

@@ -6,17 +6,15 @@
  * found in the LICENSE file at https://angular.io/license
  */
 // tslint:disable:no-any
-import 'rxjs/add/operator/toArray';
-import 'rxjs/add/operator/toPromise';
+import { toArray } from 'rxjs/operators';
 import { JsonValue } from '../json/interface';
 import { Logger } from './logger';
 
 
 describe('Logger', () => {
   it('works', (done: DoneFn) => {
     const logger = new Logger('test');
-    logger
-      .toArray()
+    logger.pipe(toArray())
       .toPromise()
       .then((observed: JsonValue[]) => {
         expect(observed).toEqual([
@@ -34,8 +32,7 @@ describe('Logger', () => {
   it('works with children', (done: DoneFn) => {
     const logger = new Logger('test');
     let hasCompleted = false;
-    logger
-      .toArray()
+    logger.pipe(toArray())
       .toPromise()
       .then((observed: JsonValue[]) => {
         expect(observed).toEqual([
@@ -57,8 +54,7 @@ describe('Logger', () => {
     const logger = new Logger('test');
     logger.debug('woah');
 
-    logger
-      .toArray()
+    logger.pipe(toArray())
       .toPromise()
       .then((observed: JsonValue[]) => {
         expect(observed).toEqual([