Merge remote-tracking branch 'origin/develop'

Author: znorman-harris

CHANGELOG.md

@@ -28,6 +28,42 @@ Added the ability to convert a notebook to a PDF! This requires an additional ex
 
 - You do need to save your notebook to disk so we have a path to write the Markdown and PDF files
 
+## 4.4.2 - April 2024
+
+For notebook cells, syntax errors are now highlighted and problems are reported on the lines that have errors. This behaves the same as PRO files when using the debug console as well.
+
+When you run a notebook cell, and IDL stops running, we now show the line in the cell that was stopped on to help track down problems.
+
+Syntax error and notebook decorations now cover the whole line instead of just the text on the line to help make them pop more.
+
+Improved the user experience for breakpoints when working with IDL. Some of the new behaviors include:
+
+- Properly setting breakpoints when you add them to a file before IDL starts
+
+- When you manually compile any file, we synchronize the actual location of breakpoints with VSCode
+
+Fixed a rare error where, when IDL was running in the debug console, we would fail to fetch internal information about IDL.
+
+When converting notebooks to PDFs, add a short pause before generating the PDF try avoid having to click the button twice.
+
+Fixed an issue where, when you would delete a notebook cell that had reported problems, the problems would always stick around in the "Problems" tab of VSCode
+
+Re-worked quote formatting to not potentially break user code. There are a few edge cases where the quotes cause errors when they were flipped from single to double (or double to single). Now, all quotes preserve the interior content of the string so that IDL interprets them the same.
+
+Fixed a small issue with syntax highlighting where we weren't detecting escaped quotes (and highlighting them) as we should have.
+
+Tweak setting IDL's DLM path when launching so that users can specify custom paths through normal environment variables and have it be supported.
+
+When IDL starts up for notebooks, we now check to make sure you have at least IDL 8.8.0 which has some required updates in order for the notebooks to function as expected.
+
+Updated the main README and notebooks docs to reflect the version requirements.
+
+When IDL starts for Notebooks, we update the kernel indicator in the top-right of the notebook to show the version of IDL we are using. We use this now instead of the pop-up window that used to appear.
+
+## 4.4.1 April 2024
+
+Fix a bug where watch variables were being executed and causing chaos in IDL debug sessions
+
 ## 4.4.0 - April 2024
 
 Fixed an issue where the names of ENVI and IDL tasks were incorrectly lower-case instead of what the user had specified in the task files.

README.md

@@ -66,7 +66,11 @@ The extension is tested against:
 
 Anything else is use-at-your-own-risk and may not work.
 
-For notebooks, we only test against the above versions, and the ENVI Notebook API does require ENVI in order to function.
+Notebooks have specific version requirements for IDL and ENVI:
+
+- For IDL, you'll need IDL 8.8.0 or newer (enforced, and checked, when notebooks start)
+
+- For ENVI, you'll need ENVI 6.0 or ENVI 5.7. Any other version of ENVI is not guaranteed to work.
 
 ## Features
 

apps/client-e2e/src/tests/debugging/_debugging-runner.ts

@@ -1,7 +1,10 @@
 import { Logger } from '@idl/logger';
 
 import { Runner } from '../runner.class';
-import { BreakPointStepInStepOut } from './breakpoint-step-in-step-out';
+import { BreakpointCompileBehavior } from './breakpoint-compile-behavior';
+import { BreakpointSetBeforeStart } from './breakpoint-set-before-start';
+import { BreakpointStepInStepOut } from './breakpoint-step-in-step-out';
+import { CleanOutput } from './clean-output';
 import { Compile } from './compile';
 import { Continue } from './continue';
 import { Edit } from './edit';
@@ -31,6 +34,12 @@ DEBUGGING_RUNNER.addTest({
   critical: true,
 });
 
+DEBUGGING_RUNNER.addTest({
+  name: 'Remove excess IDL content from IDL output (compile/restore statements)',
+  fn: CleanOutput,
+  critical: true,
+});
+
 DEBUGGING_RUNNER.addTest({
   name: 'Queue works right',
   fn: QueueRight,
@@ -54,7 +63,17 @@ DEBUGGING_RUNNER.addTest({
 
 DEBUGGING_RUNNER.addTest({
   name: 'Set breakpoints, step in, over, out, reset',
-  fn: BreakPointStepInStepOut,
+  fn: BreakpointStepInStepOut,
+});
+
+DEBUGGING_RUNNER.addTest({
+  name: 'Breakpoints behave correctly when we set before compiling a file',
+  fn: BreakpointCompileBehavior,
+});
+
+DEBUGGING_RUNNER.addTest({
+  name: 'Breakpoints get applied when set before IDL starts up',
+  fn: BreakpointSetBeforeStart,
 });
 
 DEBUGGING_RUNNER.addTest({

apps/client-e2e/src/tests/debugging/breakpoint-compile-behavior.ts

@@ -0,0 +1,81 @@
+import { GetExtensionPath, IDL_COMMANDS } from '@idl/shared';
+import { Sleep } from '@idl/tests/helpers';
+import {
+  GetActivePROCodeWindow,
+  OpenFileInVSCode,
+  VSCODE_COMMANDS,
+} from '@idl/vscode/shared';
+import expect from 'expect';
+import * as vscode from 'vscode';
+
+import { RunnerFunction } from '../runner.interface';
+import { DEBUG_PAUSE } from './_shared.interface';
+
+/**
+ * Test that makes sure breakpoints behave as we expect when we compile a file
+ */
+export const BreakpointCompileBehavior: RunnerFunction = async (init) => {
+  /**
+   * Start IDL
+   */
+  const started = await vscode.commands.executeCommand(
+    IDL_COMMANDS.DEBUG.START
+  );
+
+  // verify we started
+  expect(started).toBeTruthy();
+
+  // show the debug console
+  await vscode.commands.executeCommand(VSCODE_COMMANDS.SHOW_DEBUG_CONSOLE);
+
+  // reset breakpoints
+  await init.debug.adapter._breakpoints.resetBreakpoints();
+
+  /** Get the file we need to work with */
+  const file = GetExtensionPath(
+    'idl/test/client-e2e/debug/breakpoints/on_compile.pro'
+  );
+
+  // open editor and display
+  await OpenFileInVSCode(file);
+
+  // get current editor window
+  const editor = GetActivePROCodeWindow();
+
+  // make sure we opened a window
+  expect(editor).not.toBeUndefined();
+
+  // make sure it is the plot file
+  expect(editor.uri.fsPath.endsWith('on_compile.pro')).toBeTruthy();
+
+  // pause momentarily
+  await Sleep(DEBUG_PAUSE);
+
+  // set breakpoint
+  await init.debug.adapter._breakpoints.setBreakpoints({
+    source: {
+      path: file,
+    },
+    lines: [8, 10, 14, 19, 24],
+  });
+
+  /** Compile our file */
+  await vscode.commands.executeCommand(IDL_COMMANDS.DEBUG.COMPILE);
+
+  // pause momentarily
+  await Sleep(DEBUG_PAUSE);
+
+  // query breakpoints
+  const bps = init.debug.adapter._breakpoints.VSCodeBreakpoints.map(
+    (bp) => bp.line
+  ).sort((a, b) => a - b);
+
+  // make sure we have the right breakpoints
+  expect(bps).toEqual([8, 10, 24]);
+
+  // remove all breakpoints
+  await init.debug.adapter._breakpoints.resetBreakpoints();
+
+  // reset
+  await init.debug.adapter.evaluate('.reset');
+};

apps/client-e2e/src/tests/debugging/breakpoint-set-before-start.ts

@@ -0,0 +1,75 @@
+import { GetExtensionPath, IDL_COMMANDS } from '@idl/shared';
+import { Sleep } from '@idl/tests/helpers';
+import { OpenFileInVSCode, VSCODE_COMMANDS } from '@idl/vscode/shared';
+import expect from 'expect';
+import * as vscode from 'vscode';
+
+import { RunnerFunction } from '../runner.interface';
+import { DEBUG_PAUSE } from './_shared.interface';
+
+/**
+ * Test that makes sure breakpoints can be set before IDL starts and then
+ * we set them when IDL starts up
+ */
+export const BreakpointSetBeforeStart: RunnerFunction = async (init) => {
+  /** Get the file we need to work with */
+  const file = GetExtensionPath(
+    'idl/test/client-e2e/debug/breakpoints/before_start.pro'
+  );
+
+  // open editor and display
+  const doc = await OpenFileInVSCode(file);
+
+  // make sure we opened a window
+  expect(doc).not.toBeUndefined();
+
+  // make sure it is the plot file
+  expect(doc.uri.fsPath.endsWith('before_start.pro')).toBeTruthy();
+
+  // stop our IDL session
+  await vscode.commands.executeCommand(VSCODE_COMMANDS.DEBUG_STOP);
+
+  // short pause
+  await Sleep(100);
+
+  // make sure stopped
+  expect(init.debug.adapter.isStarted()).toBeFalsy();
+
+  // set breakpoint
+  const prom = init.debug.adapter._breakpoints.setBreakpoints({
+    source: {
+      path: file,
+    },
+    lines: [1, 3],
+  });
+
+  // short pause
+  await Sleep(DEBUG_PAUSE);
+
+  /**
+   * Start IDL
+   */
+  const started = await vscode.commands.executeCommand(
+    IDL_COMMANDS.DEBUG.START
+  );
+
+  // verify we started
+  expect(started).toBeTruthy();
+
+  // wait for breakpoints to actually be added
+  await prom;
+
+  // query breakpoints
+  const bps = init.debug.adapter._breakpoints.VSCodeBreakpoints.map(
+    (bp) => bp.line
+  );
+
+  // make sure we have the right breakpoints
+  expect(bps.sort()).toEqual([1, 3]);
+
+  // reset breakpoints
+  await init.debug.adapter._breakpoints.resetBreakpoints();
+
+  // reset
+  await init.debug.adapter.evaluate('.reset');
+};

apps/client-e2e/src/tests/debugging/breakpoint-step-in-step-out.ts

@@ -15,7 +15,7 @@ import { DEBUG_PAUSE } from './_shared.interface';
  * Test that makes sure we can set breakpoints, stop on them, step into routines, and step
  * out of them
  */
-export const BreakPointStepInStepOut: RunnerFunction = async (init) => {
+export const BreakpointStepInStepOut: RunnerFunction = async (init) => {
   /**
    * Start IDL
    */
@@ -29,6 +29,9 @@ export const BreakPointStepInStepOut: RunnerFunction = async (init) => {
   // show the debug console
   await vscode.commands.executeCommand(VSCODE_COMMANDS.SHOW_DEBUG_CONSOLE);
 
+  // reset breakpoints
+  await init.debug.adapter._breakpoints.resetBreakpoints();
+
   /** Get the file we need to work with */
   const file = GetExtensionPath('idl/test/client-e2e/step_in.pro');
 
@@ -48,7 +51,12 @@ export const BreakPointStepInStepOut: RunnerFunction = async (init) => {
   await Sleep(DEBUG_PAUSE);
 
   // set breakpoint
-  await init.debug.adapter.setBreakpoint(file, 19);
+  await init.debug.adapter._breakpoints.setBreakpoints({
+    source: {
+      path: file,
+    },
+    lines: [19],
+  });
 
   /** Run our file */
   await vscode.commands.executeCommand(IDL_COMMANDS.DEBUG.RUN);
@@ -75,6 +83,9 @@ export const BreakPointStepInStepOut: RunnerFunction = async (init) => {
   await Sleep(DEBUG_PAUSE);
   expect(init.debug.adapter.stopped?.stack?.line).toEqual(21);
 
+  // remove all breakpoints
+  await init.debug.adapter._breakpoints.resetBreakpoints();
+
   // reset
   await init.debug.adapter.evaluate('.reset');
 };

apps/client-e2e/src/tests/debugging/clean-output.ts

@@ -0,0 +1,64 @@
+import { CleanIDLOutput } from '@idl/idl';
+import { IDL_COMMANDS, Sleep } from '@idl/shared';
+import expect from 'expect';
+import * as vscode from 'vscode';
+
+import { RunnerFunction } from '../runner.interface';
+
+/**
+ * Example IDL statements that we should remove
+ */
+const STATEMENTS: string[] = [
+  `% Restored file: HASH::INIT`,
+  `% Compiled module: IMAGE::QUERYPROPERTY.`,
+  `% Compiled module: SURFACE::QUERYPROPERTY.`,
+  `% Compiled module: SCATTERPLOT::QUERYPROPERTY.`,
+  `% Compiled module: SCATTERPLOT3D::QUERYPROPERTY.`,
+  `% Compiled module: CONTOUR::QUERYPROPERTY.`,
+  `% Compiled module: TEXT::QUERYPROPERTY.`,
+  `% Compiled module: FILLPLOT::QUERYPROPERTY.`,
+  `% Compiled module: POLYGON::QUERYPROPERTY.`,
+  `% Compiled module: POLYLINE::QUERYPROPERTY.`,
+  `% Compiled module: ARROW::QUERYPROPERTY.`,
+  `% Compiled module: ELLIPSE::QUERYPROPERTY.`,
+  `% Compiled module: MAPGRID::QUERYPROPERTY.`,
+  `% Compiled module: VECTOR::QUERYPROPERTY.`,
+  `% Compiled module: STREAMLINE::QUERYPROPERTY.`,
+  `% Compiled module: MAPGRIDLINE::QUERYPROPERTY.`,
+  `% Compiled module: CROSSHAIR::QUERYPROPERTY.`,
+  `% Compiled module: VOLUME::QUERYPROPERTY.`,
+  `% Compiled module: TEXT::GETTEXTDIMENSIONS.`,
+  `% Compiled module: GRAPHIC__DEFINE.`,
+];
+
+/**
+ * Function that verifies we can clean the output from IDL when we
+ * have compiled and restore statements
+ */
+export const CleanOutput: RunnerFunction = async (init) => {
+  /**
+   * Start IDL
+   */
+  const started = await vscode.commands.executeCommand(
+    IDL_COMMANDS.DEBUG.START
+  );
+
+  // verify we started
+  expect(started).toBeTruthy();
+
+  // short pause
+  await Sleep(100);
+
+  /**
+   * Evaluate something and get result
+   */
+  const res = CleanIDLOutput(
+    await init.debug.adapter.evaluate(
+      `print, '${STATEMENTS.join(`' & print, '`)}'`,
+      { echo: true }
+    )
+  );
+
+  // verify we get the right output
+  expect(res).toEqual('');
+};

apps/client-e2e/src/tests/debugging/compile.ts

@@ -25,7 +25,8 @@ export const Compile: RunnerFunction = async (init) => {
 
   // compile file
   const res = CleanIDLOutput(
-    await init.debug.adapter.evaluate(`.compile plot`, { echo: true })
+    await init.debug.adapter.evaluate(`.compile plot`, { echo: true }),
+    false
   );
 
   // make sure we compile