[pre-commit.ci lite] apply automatic fixes

cursorless-talon/src/tutorial.py

@@ -1,17 +1,16 @@
-import json
-import re
-from pathlib import Path
 from typing import Callable
 
 from talon import actions, app
 
 from .get_action_spoken_form import lookup_action
 
+
 # {literalStep:...}
 # "To see all available scopes, use the command {literalStep:cursorless help}, and look at the Scopes section."
 def process_literal_step(argument: str):
     return f"<cmd@{argument}/>"
 
+
 # {action:...}
 # "Say {action:setSelectionAfter} to place the cursor after a target: {step:postLook.yml}",
 # "Say {action:clearAndSetSelection} to delete a word and move your cursor to where it used to be: {step:clearTrap.yml}",
@@ -20,16 +19,18 @@ def process_action(argument: str):
     _, spoken_form = lookup_action(argument)
     return f'<*"{spoken_form}"/>'
 
+
 # {scopeType:...}
 # "We can also use {scopeType:line} to refer to the line containing our cursor: {step:takeLine.yml}"
 # "Cursorless tries its best to keep your commands short. In the following command, we just say {scopeType:string} once, but cursorless infers that both targets are strings: {step:swapStringAirWithWhale.yml}"
 def process_scope_type(argument: str):
-    #_, spoken_form = lookup_scope_type(argument)
-    #return f'<*"{spoken_form}"/>'
+    # _, spoken_form = lookup_scope_type(argument)
+    # return f'<*"{spoken_form}"/>'
     return f'<*"SCOPETYPE_{argument}"/>'
 
+
 # "When editing code, we often think in terms of statements, functions, etc. Let's clone a statement: {step:cloneStateInk.yml}",
-# 
+#
 # this builds a dictionary which has keys and values (each one is a spoken form)
 # each value is built by calling the function with the argument being passed
 # eg interpolation_processor_map["step"]()
@@ -41,50 +42,54 @@ def process_scope_type(argument: str):
     # hardcoded list of default spoken form for an action (not yet the customized one)
     "action": process_action,
     # scopeTypeType == "line", etc.
-# generator.processScopeType({type: scopeTypeType})
+    # generator.processScopeType({type: scopeTypeType})
     "scopeType": process_scope_type,
 }
 
 # TODO all the above will be deleted
 
+
 def step_callback(x):
     print(f"step_callback8: {x}")
-    yamlFilename = tutorial_content['yamlFilenames'][x]
+    yamlFilename = tutorial_content["yamlFilenames"][x]
     if yamlFilename:
-        response = actions.user.private_cursorless_run_rpc_command_get(
-                "cursorless.tutorial.setupStep",
-                {
-                    "version": 0,
-                    "tutorialName": "unit-2-basic-coding",
-                    "yamlFilename": yamlFilename
-                },
-            )
+        actions.user.private_cursorless_run_rpc_command_get(
+            "cursorless.tutorial.setupStep",
+            {
+                "version": 0,
+                "tutorialName": "unit-2-basic-coding",
+                "yamlFilename": yamlFilename,
+            },
+        )
+
 
 tutorial_content = None
-def get_basic_coding_walkthrough(): 
+
+
+def get_basic_coding_walkthrough():
     global tutorial_content
     print("get_basic_coding_walkthrough start")
     tutorial_content = actions.user.private_cursorless_run_rpc_command_get(
         "cursorless.tutorial.getContent",
-        {
-            "version": 0,
-            "tutorialName": "unit-2-basic-coding"
-        },
+        {"version": 0, "tutorialName": "unit-2-basic-coding"},
     )
     print(f"{tutorial_content=}")
     walkthrough_steps = []
-    for content in tutorial_content['content']:
-        walkthrough_steps.append(actions.user.hud_create_walkthrough_step(
-            content=content,
-            restore_callback=step_callback,
-            modes=["command"],
-            app="Visual Studio Code", # Windows
-            # app="Code", # OS X?
-            context_hint="Please open VSCode and enter command mode"
-        ))
+    for content in tutorial_content["content"]:
+        walkthrough_steps.append(
+            actions.user.hud_create_walkthrough_step(
+                content=content,
+                restore_callback=step_callback,
+                modes=["command"],
+                app="Visual Studio Code",  # Windows
+                # app="Code", # OS X?
+                context_hint="Please open VSCode and enter command mode",
+            )
+        )
     print("get_basic_coding_walkthrough end")
     return walkthrough_steps
 
+
 # this is adding the menu to the hud
 # by adding a list of HudWalkThroughStep
 def on_ready():

packages/cursorless-engine/src/core/Tutorial.ts

@@ -9,14 +9,13 @@ import path from "path";
 import * as yaml from "js-yaml";
 import { promises as fsp } from "node:fs";
 
-import { SpokenForm, SpokenFormSuccess, TestCaseFixture } from "@cursorless/common";
-import { Dictionary } from "lodash";
+import { SpokenFormSuccess, TestCaseFixture } from "@cursorless/common";
 import { ide } from "../singletons/ide.singleton";
 import { HatTokenMapImpl } from "./HatTokenMapImpl";
 import { CustomSpokenFormGeneratorImpl } from "../generateSpokenForm/CustomSpokenFormGeneratorImpl";
 import { canonicalizeAndValidateCommand } from "./commandVersionUpgrades/canonicalizeAndValidateCommand";
 
-const fs = require('node:fs');
+const fs = require("node:fs");
 
 // TODO use a relative path but I'm not sure where these source files are at running time
 // and CWD is C:\Users\User\AppData\Local\Programs\Microsoft VS Code\
@@ -83,94 +82,110 @@ export class Tutorial {
   }
 
   async getContent({ version, tutorialName }: TutorialGetContentArg) {
-    console.log("getContent(){ version, tutorialName, yamlFilename }: TutorialSetupStepArg", tutorialName);
+    console.log(
+      "getContent(){ version, tutorialName, yamlFilename }: TutorialSetupStepArg",
+      tutorialName,
+    );
     if (version !== 0) {
       throw new Error(`Unsupported tutorial api version: ${version}`);
     }
 
     const tutorialDir = path.join(tutorialRootDir, tutorialName);
     if (!fs.existsSync(tutorialDir)) {
-        throw new Error(`Invalid tutorial name: ${tutorialName}`);
-    } 
-    
+      throw new Error(`Invalid tutorial name: ${tutorialName}`);
+    }
+
     const scriptFile = path.join(tutorialDir, "script.json");
     if (!fs.existsSync(scriptFile)) {
-        throw new Error(`Can't file script file: ${scriptFile} in tutorial name: ${tutorialName}`);
+      throw new Error(
+        `Can't file script file: ${scriptFile} in tutorial name: ${tutorialName}`,
+      );
     }
     const buffer = await fsp.readFile(scriptFile);
     const contentList = JSON.parse(buffer.toString());
     console.log(contentList);
 
     // this is trying to catch occurrences of things like "{step:cloneStateInk.yml}"
     const re = /\{(\w+):([^}]+)\}/g;
-    
-    var m;
-    var response : TutorialGetContentResponse = {
+
+    let m;
+    const response: TutorialGetContentResponse = {
       version: 0,
       content: [],
       yamlFilenames: [],
     };
     // we need to replace the {...} with the right content
-    for (var content of contentList) {
-      var yamlFilename = ""; 
+    for (let content of contentList) {
+      let yamlFilename = "";
       do {
         m = re.exec(content);
         if (m) {
           const name = m[1];
           const arg = m[2];
           console.log(name, arg);
-          if (name === "step")
-          {
+          if (name === "step") {
             const tutorialDir = path.join(tutorialRootDir, tutorialName);
             if (!fs.existsSync(tutorialDir)) {
-                throw new Error(`Invalid tutorial name: ${tutorialName}`);
-            } 
-            
-            const yamlFile = path.join(tutorialDir, arg)
+              throw new Error(`Invalid tutorial name: ${tutorialName}`);
+            }
+
+            const yamlFile = path.join(tutorialDir, arg);
             if (!fs.existsSync(yamlFile)) {
-                throw new Error(`Can't file yaml file: ${yamlFile} in tutorial name: ${tutorialName}`);
+              throw new Error(
+                `Can't file yaml file: ${yamlFile} in tutorial name: ${tutorialName}`,
+              );
             }
             yamlFilename = arg;
-                        
+
             const buffer = await fsp.readFile(yamlFile);
             const fixture = yaml.load(buffer.toString()) as TestCaseFixture;
-            
+
             // command to be said for moving to the next step
-            const spoken_form = this.customSpokenFormGenerator.commandToSpokenForm(
-              canonicalizeAndValidateCommand(fixture.command)
-            ) as SpokenFormSuccess;
+            const spoken_form =
+              this.customSpokenFormGenerator.commandToSpokenForm(
+                canonicalizeAndValidateCommand(fixture.command),
+              ) as SpokenFormSuccess;
             console.log("\t", spoken_form.spokenForms[0]);
-            content = content.replace(m[0], `<cmd@${spoken_form.spokenForms[0]}/>`)
+            content = content.replace(
+              m[0],
+              `<cmd@${spoken_form.spokenForms[0]}/>`,
+            );
           }
         }
       } while (m);
       response.yamlFilenames.push(yamlFilename);
       response.content.push(content);
     }
-    
+
     // return to the talon side
     return response;
   }
 
-  async setupStep({ version, tutorialName, yamlFilename }: TutorialSetupStepArg) {
+  async setupStep({
+    version,
+    tutorialName,
+    yamlFilename,
+  }: TutorialSetupStepArg) {
     console.log("setupStep()", tutorialName, yamlFilename);
     if (version !== 0) {
       throw new Error(`Unsupported tutorial api version: ${version}`);
     }
 
     const tutorialDir = path.join(tutorialRootDir, tutorialName);
     if (!fs.existsSync(tutorialDir)) {
-        throw new Error(`Invalid tutorial name: ${tutorialName}`);
+      throw new Error(`Invalid tutorial name: ${tutorialName}`);
     }
-    
+
     // TODO check for directory traversal?
     const yamlFile = path.join(tutorialDir, yamlFilename);
     if (!fs.existsSync(yamlFile)) {
-        throw new Error(`Can't file yaml file: ${yamlFile} in tutorial name: ${tutorialName}`);
+      throw new Error(
+        `Can't file yaml file: ${yamlFile} in tutorial name: ${tutorialName}`,
+      );
     }
     const buffer = await fsp.readFile(yamlFile);
     const fixture = yaml.load(buffer.toString()) as TestCaseFixture;
-    
+
     const editor = ide().openUntitledTextDocument({
       content: fixture.initialState.documentContents,
       language: fixture.languageId,
@@ -181,4 +196,4 @@ export class Tutorial {
     // return to the talon side
     return true;
   }
-}
+}