@jupyterlab/debugger 4.0.0-alpha.9 → 4.0.0-beta.1

package/src/hash.ts

@@ -0,0 +1,69 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+// Most of the implementation below is adapted from the following repository:
+// https://github.com/garycourt/murmurhash-js/blob/master/murmurhash2_gc.js
+// Which has the following MIT License:
+//
+// Copyright (c) 2011 Gary Court
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+// and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+//  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// The implementation below uses case fallthrough as part of the algorithm.
+/* eslint-disable no-fallthrough */
+
+const m = 0x5bd1e995;
+const encoder = new TextEncoder();
+
+/**
+ * Calculate the murmurhash2 for a given string and seed.
+ *
+ * @param str The string to calculate the Murmur2 hash for.
+ * @param seed The seed.
+ *
+ * @returns The Murmurhash2 hash.
+ */
+export function murmur2(str: string, seed: number): number {
+  const data = encoder.encode(str);
+  let len = data.length;
+  let h = seed ^ len;
+  let i = 0;
+
+  while (len >= 4) {
+    let k =
+      (data[i] & 0xff) |
+      ((data[++i] & 0xff) << 8) |
+      ((data[++i] & 0xff) << 16) |
+      ((data[++i] & 0xff) << 24);
+
+    k = (k & 0xffff) * m + ((((k >>> 16) * m) & 0xffff) << 16);
+    k ^= k >>> 24;
+    k = (k & 0xffff) * m + ((((k >>> 16) * m) & 0xffff) << 16);
+
+    h = ((h & 0xffff) * m + ((((h >>> 16) * m) & 0xffff) << 16)) ^ k;
+
+    len -= 4;
+    ++i;
+  }
+
+  switch (len) {
+    case 3:
+      h ^= (data[i + 2] & 0xff) << 16;
+    case 2:
+      h ^= (data[i + 1] & 0xff) << 8;
+    case 1:
+      h ^= data[i] & 0xff;
+      h = (h & 0xffff) * m + ((((h >>> 16) * m) & 0xffff) << 16);
+  }
+
+  h ^= h >>> 13;
+  h = (h & 0xffff) * m + ((((h >>> 16) * m) & 0xffff) << 16);
+  h ^= h >>> 15;
+
+  return h >>> 0;
+}

package/src/icons.ts

@@ -0,0 +1,64 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { LabIcon } from '@jupyterlab/ui-components';
+
+import closeAllSvgStr from '../style/icons/close-all.svg';
+import stepIntoSvgStr from '../style/icons/step-into.svg';
+import stepOutSvgStr from '../style/icons/step-out.svg';
+import stepOverSvgStr from '../style/icons/step-over.svg';
+import variableSvgStr from '../style/icons/variable.svg';
+import pauseSvgStr from '../style/icons/pause.svg';
+import viewBreakpointSvgStr from '../style/icons/view-breakpoint.svg';
+import openKernelSourceSvgStr from '../style/icons/open-kernel-source.svg';
+import exceptionSvgStr from '../style/icons/exceptions.svg';
+
+export {
+  runIcon as continueIcon,
+  stopIcon as terminateIcon
+} from '@jupyterlab/ui-components';
+
+export const closeAllIcon = new LabIcon({
+  name: 'debugger:close-all',
+  svgstr: closeAllSvgStr
+});
+
+export const exceptionIcon = new LabIcon({
+  name: 'debugger:pause-on-exception',
+  svgstr: exceptionSvgStr
+});
+
+export const pauseIcon = new LabIcon({
+  name: 'debugger:pause',
+  svgstr: pauseSvgStr
+});
+
+export const stepIntoIcon = new LabIcon({
+  name: 'debugger:step-into',
+  svgstr: stepIntoSvgStr
+});
+
+export const stepOverIcon = new LabIcon({
+  name: 'debugger:step-over',
+  svgstr: stepOverSvgStr
+});
+
+export const stepOutIcon = new LabIcon({
+  name: 'debugger:step-out',
+  svgstr: stepOutSvgStr
+});
+
+export const variableIcon = new LabIcon({
+  name: 'debugger:variable',
+  svgstr: variableSvgStr
+});
+
+export const viewBreakpointIcon = new LabIcon({
+  name: 'debugger:view-breakpoint',
+  svgstr: viewBreakpointSvgStr
+});
+
+export const openKernelSourceIcon = new LabIcon({
+  name: 'debugger:open-kernel-source',
+  svgstr: openKernelSourceSvgStr
+});

package/src/index.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+/**
+ * @packageDocumentation
+ * @module debugger
+ */
+
+export { Debugger } from './debugger';
+
+export {
+  IDebugger,
+  IDebuggerConfig,
+  IDebuggerSources,
+  IDebuggerSidebar,
+  IDebuggerHandler
+} from './tokens';

package/src/model.ts

@@ -0,0 +1,155 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { IDebugger } from './tokens';
+
+import { ISignal, Signal } from '@lumino/signaling';
+
+import { BreakpointsModel } from './panels/breakpoints/model';
+
+import { CallstackModel } from './panels/callstack/model';
+
+import { SourcesModel } from './panels/sources/model';
+
+import { KernelSourcesModel } from './panels/kernelSources/model';
+
+import { VariablesModel } from './panels/variables/model';
+
+/**
+ * A model for a debugger.
+ */
+export class DebuggerModel implements IDebugger.Model.IService {
+  /**
+   * Instantiate a new DebuggerModel
+   */
+  constructor() {
+    this.breakpoints = new BreakpointsModel();
+    this.callstack = new CallstackModel();
+    this.variables = new VariablesModel();
+    this.sources = new SourcesModel({
+      currentFrameChanged: this.callstack.currentFrameChanged
+    });
+    this.kernelSources = new KernelSourcesModel();
+  }
+
+  /**
+   * The breakpoints model.
+   */
+  readonly breakpoints: BreakpointsModel;
+
+  /**
+   * The callstack model.
+   */
+  readonly callstack: CallstackModel;
+
+  /**
+   * The variables model.
+   */
+  readonly variables: VariablesModel;
+
+  /**
+   * The sources model.
+   */
+  readonly sources: SourcesModel;
+
+  /**
+   * The sources model.
+   */
+  readonly kernelSources: KernelSourcesModel;
+
+  /**
+   * A signal emitted when the debugger widget is disposed.
+   */
+  get disposed(): ISignal<this, void> {
+    return this._disposed;
+  }
+
+  /**
+   * Whether the kernel support rich variable rendering based on mime type.
+   */
+  get hasRichVariableRendering(): boolean {
+    return this._hasRichVariableRendering;
+  }
+  set hasRichVariableRendering(v: boolean) {
+    this._hasRichVariableRendering = v;
+  }
+
+  /**
+   * Whether the model is disposed.
+   */
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  /**
+   * The set of threads in stopped state.
+   */
+  get stoppedThreads(): Set<number> {
+    return this._stoppedThreads;
+  }
+
+  /**
+   * Assigns the parameters to the set of threads in stopped state.
+   */
+  set stoppedThreads(threads: Set<number>) {
+    this._stoppedThreads = threads;
+  }
+
+  /**
+   * The current debugger title.
+   */
+  get title(): string {
+    return this._title;
+  }
+
+  /**
+   * Set the current debugger title.
+   */
+  set title(title: string) {
+    if (title === this._title) {
+      return;
+    }
+    this._title = title ?? '-';
+    this._titleChanged.emit(title);
+  }
+
+  /**
+   * A signal emitted when the title changes.
+   */
+  get titleChanged(): ISignal<this, string> {
+    return this._titleChanged;
+  }
+
+  /**
+   * Dispose the model.
+   */
+  dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    this.kernelSources.dispose();
+    this._disposed.emit();
+  }
+
+  /**
+   * Clear the model.
+   */
+  clear(): void {
+    this._stoppedThreads.clear();
+    const breakpoints = new Map<string, IDebugger.IBreakpoint[]>();
+    this.breakpoints.restoreBreakpoints(breakpoints);
+    this.callstack.frames = [];
+    this.variables.scopes = [];
+    this.sources.currentSource = null;
+    this.kernelSources.kernelSources = null;
+    this.title = '-';
+  }
+
+  private _disposed = new Signal<this, void>(this);
+  private _isDisposed = false;
+  private _hasRichVariableRendering = false;
+  private _stoppedThreads = new Set<number>();
+  private _title = '-';
+  private _titleChanged = new Signal<this, string>(this);
+}

package/src/panels/breakpoints/body.tsx

@@ -0,0 +1,145 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { ReactWidget } from '@jupyterlab/ui-components';
+import React, { useEffect, useState } from 'react';
+import { IDebugger } from '../../tokens';
+
+/**
+ * The body for a Breakpoints Panel.
+ */
+export class BreakpointsBody extends ReactWidget {
+  /**
+   * Instantiate a new Body for the Breakpoints Panel.
+   *
+   * @param model The model for the breakpoints.
+   */
+  constructor(model: IDebugger.Model.IBreakpoints) {
+    super();
+    this._model = model;
+    this.addClass('jp-DebuggerBreakpoints-body');
+  }
+
+  /**
+   * Render the BreakpointsComponent.
+   */
+  render(): JSX.Element {
+    return <BreakpointsComponent model={this._model} />;
+  }
+
+  private _model: IDebugger.Model.IBreakpoints;
+}
+
+/**
+ * A React component to display a list of breakpoints.
+ *
+ * @param {object} props The component props.
+ * @param props.model The model for the breakpoints.
+ */
+const BreakpointsComponent = ({
+  model
+}: {
+  model: IDebugger.Model.IBreakpoints;
+}): JSX.Element => {
+  const [breakpoints, setBreakpoints] = useState(
+    Array.from(model.breakpoints.entries())
+  );
+
+  useEffect(() => {
+    const updateBreakpoints = (
+      _: IDebugger.Model.IBreakpoints,
+      updates: IDebugger.IBreakpoint[]
+    ): void => {
+      setBreakpoints(Array.from(model.breakpoints.entries()));
+    };
+
+    const restoreBreakpoints = (_: IDebugger.Model.IBreakpoints): void => {
+      setBreakpoints(Array.from(model.breakpoints.entries()));
+    };
+
+    model.changed.connect(updateBreakpoints);
+    model.restored.connect(restoreBreakpoints);
+
+    return (): void => {
+      model.changed.disconnect(updateBreakpoints);
+      model.restored.disconnect(restoreBreakpoints);
+    };
+  });
+
+  return (
+    <>
+      {breakpoints.map(entry => (
+        <BreakpointCellComponent
+          key={entry[0]}
+          breakpoints={entry[1]}
+          model={model}
+        />
+      ))}
+    </>
+  );
+};
+
+/**
+ * A React Component to display breakpoints grouped by source file.
+ *
+ * @param {object} props The component props.
+ * @param props.breakpoints The list of breakpoints.
+ * @param props.model The model for the breakpoints.
+ */
+const BreakpointCellComponent = ({
+  breakpoints,
+  model
+}: {
+  breakpoints: IDebugger.IBreakpoint[];
+  model: IDebugger.Model.IBreakpoints;
+}): JSX.Element => {
+  return (
+    <>
+      {breakpoints
+        .sort((a, b) => {
+          return (a.line ?? 0) - (b.line ?? 0);
+        })
+        .map((breakpoint: IDebugger.IBreakpoint, index) => (
+          <BreakpointComponent
+            key={(breakpoint.source?.path ?? '') + index}
+            breakpoint={breakpoint}
+            model={model}
+          />
+        ))}
+    </>
+  );
+};
+
+/**
+ * A React Component to display a single breakpoint.
+ *
+ * @param {object} props The component props.
+ * @param props.breakpoint The breakpoint.
+ * @param props.model The model for the breakpoints.
+ */
+const BreakpointComponent = ({
+  breakpoint,
+  model
+}: {
+  breakpoint: IDebugger.IBreakpoint;
+  model: IDebugger.Model.IBreakpoints;
+}): JSX.Element => {
+  const moveToEndFirstCharIfSlash = (breakpointSourcePath: string): string => {
+    return breakpointSourcePath[0] === '/'
+      ? breakpointSourcePath.slice(1) + '/'
+      : breakpointSourcePath;
+  };
+  return (
+    <div
+      className={'jp-DebuggerBreakpoint'}
+      onClick={(): void => model.clicked.emit(breakpoint)}
+      title={breakpoint.source?.path}
+    >
+      <span className={'jp-DebuggerBreakpoint-marker'}>●</span>
+      <span className={'jp-DebuggerBreakpoint-source jp-left-truncated'}>
+        {moveToEndFirstCharIfSlash(breakpoint.source?.path ?? '')}
+      </span>
+      <span className={'jp-DebuggerBreakpoint-line'}>{breakpoint.line}</span>
+    </div>
+  );
+};

package/src/panels/breakpoints/index.ts

@@ -0,0 +1,116 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { Dialog, showDialog } from '@jupyterlab/apputils';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { PanelWithToolbar, ToolbarButton } from '@jupyterlab/ui-components';
+import { CommandRegistry } from '@lumino/commands';
+import { Signal } from '@lumino/signaling';
+import { Panel } from '@lumino/widgets';
+import { closeAllIcon, exceptionIcon } from '../../icons';
+import { IDebugger } from '../../tokens';
+import { BreakpointsBody } from './body';
+import { PauseOnExceptionsWidget } from './pauseonexceptions';
+
+/**
+ * A Panel to show a list of breakpoints.
+ */
+export class Breakpoints extends PanelWithToolbar {
+  /**
+   * Instantiate a new Breakpoints Panel.
+   *
+   * @param options The instantiation options for a Breakpoints Panel.
+   */
+  constructor(options: Breakpoints.IOptions) {
+    super(options);
+    const { model, service, commands } = options;
+    const trans = (options.translator ?? nullTranslator).load('jupyterlab');
+    this.title.label = trans.__('Breakpoints');
+
+    const body = new BreakpointsBody(model);
+
+    this.toolbar.addItem(
+      'pauseOnException',
+      new PauseOnExceptionsWidget({
+        service: service,
+        commands: commands,
+        icon: exceptionIcon,
+        tooltip: trans.__('Pause on exception filter')
+      })
+    );
+
+    this.toolbar.addItem(
+      'closeAll',
+      new ToolbarButton({
+        icon: closeAllIcon,
+        onClick: async (): Promise<void> => {
+          if (model.breakpoints.size === 0) {
+            return;
+          }
+          const result = await showDialog({
+            title: trans.__('Remove All Breakpoints'),
+            body: trans.__('Are you sure you want to remove all breakpoints?'),
+            buttons: [
+              Dialog.okButton({ label: trans.__('Remove breakpoints') }),
+              Dialog.cancelButton()
+            ],
+            hasClose: true
+          });
+          if (result.button.accept) {
+            return service.clearBreakpoints();
+          }
+        },
+        tooltip: trans.__('Remove All Breakpoints')
+      })
+    );
+
+    this.addWidget(body);
+    this.addClass('jp-DebuggerBreakpoints');
+  }
+
+  readonly clicked = new Signal<this, IDebugger.IBreakpoint>(this);
+}
+
+/**
+ * A namespace for Breakpoints `statics`.
+ */
+export namespace Breakpoints {
+  /**
+   * The toolbar commands and registry for the breakpoints.
+   */
+  export interface ICommands {
+    /**
+     * The command registry.
+     */
+    registry: CommandRegistry;
+
+    /**
+     * The pause on exceptions command ID.
+     */
+    pauseOnExceptions: string;
+  }
+  /**
+   * Instantiation options for `Breakpoints`.
+   */
+  export interface IOptions extends Panel.IOptions {
+    /**
+     * The breakpoints model.
+     */
+    model: IDebugger.Model.IBreakpoints;
+
+    /**
+     * The debugger service.
+     */
+    service: IDebugger;
+
+    /**
+     * The toolbar commands interface for the callstack.
+     */
+    commands: ICommands;
+
+    /**
+     * The application language translator..
+     */
+    translator?: ITranslator;
+  }
+}

package/src/panels/breakpoints/model.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { ISignal, Signal } from '@lumino/signaling';
+
+import { IDebugger } from '../../tokens';
+
+/**
+ * A model for a list of breakpoints.
+ */
+export class BreakpointsModel implements IDebugger.Model.IBreakpoints {
+  /**
+   * Signal emitted when the model changes.
+   */
+  get changed(): ISignal<this, IDebugger.IBreakpoint[]> {
+    return this._changed;
+  }
+
+  /**
+   * Signal emitted when the breakpoints are restored.
+   */
+  get restored(): ISignal<this, void> {
+    return this._restored;
+  }
+
+  /**
+   * Signal emitted when a breakpoint is clicked.
+   */
+  get clicked(): Signal<this, IDebugger.IBreakpoint> {
+    return this._clicked;
+  }
+
+  /**
+   * Get all the breakpoints.
+   */
+  get breakpoints(): Map<string, IDebugger.IBreakpoint[]> {
+    return this._breakpoints;
+  }
+
+  /**
+   * Set the breakpoints for a given id (path).
+   *
+   * @param id The code id (path).
+   * @param breakpoints The list of breakpoints.
+   */
+  setBreakpoints(id: string, breakpoints: IDebugger.IBreakpoint[]): void {
+    this._breakpoints.set(id, breakpoints);
+    this._changed.emit(breakpoints);
+  }
+
+  /**
+   * Get the breakpoints for a given id (path).
+   *
+   * @param id The code id (path).
+   */
+  getBreakpoints(id: string): IDebugger.IBreakpoint[] {
+    return this._breakpoints.get(id) ?? [];
+  }
+
+  /**
+   * Restore a map of breakpoints.
+   *
+   * @param breakpoints The map of breakpoints
+   */
+  restoreBreakpoints(breakpoints: Map<string, IDebugger.IBreakpoint[]>): void {
+    this._breakpoints = breakpoints;
+    this._restored.emit();
+  }
+
+  private _breakpoints = new Map<string, IDebugger.IBreakpoint[]>();
+  private _changed = new Signal<this, IDebugger.IBreakpoint[]>(this);
+  private _restored = new Signal<this, void>(this);
+  private _clicked = new Signal<this, IDebugger.IBreakpoint>(this);
+}