Maintain enabled OperatorLogPoint when changing underlying soure code (#104)

* Move OperatorLogPointManager
* Add intersection Map Util
* Implement OperatorLogPointMerger

Fixes #102

Author: swissmanu

packages/extension/src/__mocks__/vscode.ts

@@ -129,7 +129,7 @@ export class Uri implements UriType {
   }
 
   toString(skipEncoding?: boolean): string {
-    return '';
+    return `${this.scheme}${this.authority}${this.path}${this.query}${this.fragment}`;
   }
 
   toJSON(): any {

packages/extension/src/commands/operatorLogPointManagement.ts

@@ -2,47 +2,47 @@ import { interfaces } from 'inversify';
 import * as vscode from 'vscode';
 import { ILogger } from '../logger';
 import OperatorLogPoint from '../operatorLogPoint';
-import { IOperatorLogPointManager } from '../operatorLogPoint/logPointManager';
+import { IOperatorLogPointManager } from '../operatorLogPoint/manager';
 import { Commands } from './commands';
 import registerCommand from './registerCommand';
 
 export default function registerOperatorLogPointManagementCommands(
   context: vscode.ExtensionContext,
   container: interfaces.Container
 ): void {
-  const logPointManager = container.get<IOperatorLogPointManager>(IOperatorLogPointManager);
+  const manager = container.get<IOperatorLogPointManager>(IOperatorLogPointManager);
   const logger = container.get<ILogger>(ILogger);
 
   context.subscriptions.push(
     registerCommand(vscode.commands, Commands.EnableOperatorLogPoint, async (operatorLogPoint) => {
       if (typeof operatorLogPoint === 'string') {
         try {
           const parsed = OperatorLogPoint.parse(operatorLogPoint);
-          logPointManager.enable(parsed);
+          manager.enable(parsed);
         } catch (e) {
           logger.warn(
             'Extension',
             `Tried to enable serialized OperatorLogPoint, but could not parse it. ("${operatorLogPoint}")`
           );
         }
       } else {
-        logPointManager.enable(operatorLogPoint);
+        manager.enable(operatorLogPoint);
       }
     }),
 
     registerCommand(vscode.commands, Commands.DisableOperatorLogPoint, async (operatorLogPoint) => {
       if (typeof operatorLogPoint === 'string') {
         try {
           const parsed = OperatorLogPoint.parse(operatorLogPoint);
-          logPointManager.disable(parsed);
+          manager.disable(parsed);
         } catch (e) {
           logger.warn(
             'Extension',
             `Tried to disable serialized OperatorLogPoint, but could not parse it. ("${operatorLogPoint}")`
           );
         }
       } else {
-        logPointManager.disable(operatorLogPoint);
+        manager.disable(operatorLogPoint);
       }
     })
   );

packages/extension/src/decoration/decorationManager.ts

@@ -2,7 +2,7 @@ import { inject, injectable, interfaces } from 'inversify';
 import type * as vscodeApiType from 'vscode';
 import { RootContainer, VsCodeApi } from '../ioc/types';
 import { ILogger } from '../logger';
-import { IOperatorLogPointManager } from '../operatorLogPoint/logPointManager';
+import { IOperatorLogPointManager } from '../operatorLogPoint/manager';
 import { IOperatorLogPointRecommender } from '../operatorLogPoint/recommender';
 import { IResourceProvider } from '../resources';
 import { ISessionManager } from '../sessionManager';

packages/extension/src/decoration/liveLogDecorationProvider.ts

@@ -5,7 +5,7 @@ import { DecorationRangeBehavior, Range, TextDocument, TextEditor, ThemeColor, w
 import { DocumentDecorationProvider } from '.';
 import { Colors } from '../colors';
 import { Configuration } from '../configuration';
-import { IOperatorLogPointManager } from '../operatorLogPoint/logPointManager';
+import { IOperatorLogPointManager } from '../operatorLogPoint/manager';
 import { ISessionManager } from '../sessionManager';
 import { ISession } from '../sessionManager/session';
 import { IDisposable } from '../util/types';

packages/extension/src/decoration/operatorLogPointDecorationProvider/index.ts

@@ -10,9 +10,9 @@ import {
 } from 'vscode';
 import { DocumentDecorationProvider } from '..';
 import OperatorLogPoint from '../../operatorLogPoint';
-import { IOperatorLogPointManager } from '../../operatorLogPoint/logPointManager';
+import { IOperatorLogPointManager } from '../../operatorLogPoint/manager';
 import { IOperatorLogPointRecommendationEvent, IOperatorLogPointRecommender } from '../../operatorLogPoint/recommender';
-import { difference } from '../../util/map';
+import difference from '../../util/map/difference';
 import { IDisposable } from '../../util/types';
 import { IDecorationSetter } from '../decorationSetter';
 import createHoverMessageForLogPoints from './createHoverMessageForLogPoint';

packages/extension/src/decoration/operatorLogPointGutterIconDecorationProvider/index.ts

@@ -12,10 +12,10 @@ import {
 import { DocumentDecorationProvider } from '..';
 import { Configuration } from '../../configuration';
 import OperatorLogPoint from '../../operatorLogPoint';
-import { IOperatorLogPointManager } from '../../operatorLogPoint/logPointManager';
+import { IOperatorLogPointManager } from '../../operatorLogPoint/manager';
 import { IOperatorLogPointRecommendationEvent, IOperatorLogPointRecommender } from '../../operatorLogPoint/recommender';
 import { IResourceProvider } from '../../resources';
-import { difference } from '../../util/map';
+import difference from '../../util/map/difference';
 import { IDisposable } from '../../util/types';
 import { IDecorationSetter } from '../decorationSetter';
 import getEnabledState from './getEnabledState';

packages/extension/src/ioc/rootContainer.ts

@@ -9,7 +9,7 @@ import DecorationManager, { IDecorationManager } from '../decoration/decorationM
 import { default as DefaultDecorationSetter, IDecorationSetter } from '../decoration/decorationSetter';
 import Logger, { ILogger, logLevelFromString } from '../logger';
 import ConsoleLogSink from '../logger/console';
-import LogPointManager, { IOperatorLogPointManager } from '../operatorLogPoint/logPointManager';
+import OperatorLogPointManager, { IOperatorLogPointManager } from '../operatorLogPoint/manager';
 import OperatorLogPointRecommender, { IOperatorLogPointRecommender } from '../operatorLogPoint/recommender';
 import DefaultResourceProvider, { IResourceProvider } from '../resources';
 import SessionManager, { ISessionManager } from '../sessionManager';
@@ -64,7 +64,7 @@ export default function createRootContainer(
     .to(OperatorLogPointRecommender)
     .inSingletonScope()
     .onActivation(container.trackDisposableBinding);
-  container.bind<IOperatorLogPointManager>(IOperatorLogPointManager).to(LogPointManager).inSingletonScope();
+  container.bind<IOperatorLogPointManager>(IOperatorLogPointManager).to(OperatorLogPointManager).inSingletonScope();
 
   container.bind<IDecorationSetter>(IDecorationSetter).to(DecorationSetter).inSingletonScope();
   container

packages/extension/src/operatorLogPoint/index.ts

@@ -9,6 +9,7 @@ interface IOperatorLogPoint {
   operatorIdentifier: IOperatorIdentifier;
   operatorName: string | null;
   enabled: boolean;
+  key: string;
 }
 
 export default class OperatorLogPoint implements IOperatorLogPoint {

packages/extension/src/operatorLogPoint/logPointManager.test.ts renamed to packages/extension/src/operatorLogPoint/manager/index.test.ts

@@ -1,13 +1,20 @@
 import 'reflect-metadata';
-import Logger from '../logger';
-import { logPointFixtureA, logPointFixtureB } from './index.fixture';
-import LogPointManager from './logPointManager';
+import Logger from '../../logger';
+import { logPointFixtureA, logPointFixtureB } from '../index.fixture';
+import OperatorLogPointManager from '.';
+import { IOperatorLogPointRecommender } from '../recommender';
 
 describe('OperatorLogPointManager', () => {
-  let logPointManager: LogPointManager;
+  let logPointManager: OperatorLogPointManager;
+  let recommender: IOperatorLogPointRecommender;
 
   beforeEach(() => {
-    logPointManager = new LogPointManager(Logger.nullLogger());
+    recommender = {
+      dispose: jest.fn(),
+      onRecommendOperatorLogPoints: jest.fn(),
+      recommend: jest.fn(),
+    };
+    logPointManager = new OperatorLogPointManager(recommender, Logger.nullLogger());
   });
 
   describe('enable()', () => {

packages/extension/src/operatorLogPoint/logPointManager.ts renamed to packages/extension/src/operatorLogPoint/manager/index.ts

@@ -2,9 +2,11 @@ import { IOperatorIdentifier } from '@rxjs-debugging/telemetry/out/operatorIdent
 import operatorIdentifierToString from '@rxjs-debugging/telemetry/out/operatorIdentifier/toString';
 import { inject, injectable } from 'inversify';
 import { Event, EventEmitter } from 'vscode';
-import OperatorLogPoint from '.';
-import { ILogger } from '../logger';
-import { IDisposable } from '../util/types';
+import OperatorLogPoint from '..';
+import { ILogger } from '../../logger';
+import { IDisposable } from '../../util/types';
+import { IOperatorLogPointRecommender } from '../recommender';
+import OperatorLogPointMerger from './merger';
 
 export const IOperatorLogPointManager = Symbol('OperatorLogPointManager');
 
@@ -16,16 +18,37 @@ export interface IOperatorLogPointManager extends IDisposable {
   onDidChangeLogPoints: Event<ReadonlyArray<OperatorLogPoint>>;
 }
 
+/**
+ * Manages enabled `OperatorLogPoint`s.
+ */
 @injectable()
-export default class LogPointManager implements IOperatorLogPointManager {
-  private readonly _logPoints: Map<string, OperatorLogPoint> = new Map();
+export default class OperatorLogPointManager implements IOperatorLogPointManager {
+  /**
+   * A map with `OperatorLogPoint`s. The key is equivalent with the operator log points `key` property.
+   */
+  private _logPoints: Map<string, OperatorLogPoint> = new Map();
 
   private _onDidChangeLogPoints = new EventEmitter<ReadonlyArray<OperatorLogPoint>>();
   get onDidChangeLogPoints(): Event<ReadonlyArray<OperatorLogPoint>> {
     return this._onDidChangeLogPoints.event;
   }
 
-  constructor(@inject(ILogger) private readonly logger: ILogger) {}
+  private readonly onRecommendOperatorLogPointsDisposable: IDisposable;
+
+  constructor(
+    @inject(IOperatorLogPointRecommender) recommender: IOperatorLogPointRecommender,
+    @inject(ILogger) private readonly logger: ILogger
+  ) {
+    const merger = new OperatorLogPointMerger();
+
+    this.onRecommendOperatorLogPointsDisposable = recommender.onRecommendOperatorLogPoints(
+      ({ operatorLogPoints: newlyRecommended }) => {
+        this.logger.info('LogPointManager', 'Update log points with latest recommendations');
+        this._logPoints = new Map(merger.merge(this.logPoints, newlyRecommended).map((l) => [l.key, l]));
+        this._onDidChangeLogPoints.fire(this.logPoints);
+      }
+    );
+  }
 
   enable(operatorLogPoint: OperatorLogPoint): void {
     const enabledOperatorLogPoint = operatorLogPoint.with({ enabled: true });
@@ -59,5 +82,6 @@ export default class LogPointManager implements IOperatorLogPointManager {
 
   dispose(): void {
     this._onDidChangeLogPoints.dispose();
+    this.onRecommendOperatorLogPointsDisposable.dispose();
   }
 }