tpmkms_4wp 9.5.1 → 9.6.0-beta.1

package/common/asking.js

@@ -12,8 +12,8 @@ const config = {
   name: 'asking',
   operators: [
     "([nevermind])",
-    { pattern: "([nevermindTestSetup] (allowed))", development: true },
-    { pattern: "([whichOnesTestSetup] (choices)*)", development: true },
+    { pattern: "([nevermindTestSetup] (allowed))", scope: "testing" },
+    { pattern: "([whichOnesTestSetup] (choices)*)", scope: "testing" },
   ],
   bridges: [
     {
@@ -22,32 +22,37 @@ const config = {
       semantic: (args) => {
         const {config, context} = args
         // stop asking all questions
-        for (const semantic of config.semantics) {
+        const remove = []
+        for (const semantic of config.semantics()) {
           if (semantic.isQuestion) {
             let doRemove = true
             if (semantic.onNevermind && semantic.getWasAsked() && !semantic.getWasApplied()) {
               doRemove = semantic.onNevermind(args)
             }
             if (doRemove) {
-              config.removeSemantic(semantic)
+              remove.push(semantic)
+              // config.removeSemantic(semantic)
             }
           }
         }
+        for (const semantic of remove) {
+          config.removeSemantic(semantic)
+        }
       }
     },
 
     {
       id: "whichOnesTestSetup",
-      development: true,
+      scope: "testing",
       generatorp: async ({context, gs}) => `${context.marker} ${await gs(context.choices)}`,
       bridge: "{ ...next(operator), choices: after[0] }",
       semantic: ({askWhich, context}) => {
         const choices = context.choices
-        const chosen = ({ choice, objects }) => {
+        function chosen({ choice, objects }) {
           objects.choice = choice
         }
 
-        const question = async ({choices, g, gs, wasAsked, state}) => {
+        async function question({choices, g, gs, wasAsked, state}) {
           if (wasAsked) {
             return `${await g(state.lastChoice)} is not a choice. The choices are: ${await gs(choices, ' ', ' or ')}`
           } else {
@@ -55,7 +60,7 @@ const config = {
           }
         }
 
-        const isChoice = ({context, choices, state}) => {
+        function isChoice({context, choices, state}) {
           state.lastChoice = context
           for (const choice of choices) {
             if (choice.value == context.value) {
@@ -64,7 +69,7 @@ const config = {
           }
         }
 
-        const onNevermind = ({objects, context}) => {
+        function onNevermind({objects, context}) {
           objects.onNevermindWasCalled = true
           return true
         }
@@ -75,7 +80,7 @@ const config = {
 
     {
       id: "nevermindTestSetup",
-      development: true,
+      scope: "testing",
       bridge: "{ ...next(operator), type: after[0], postModifiers: ['type'] }",
       semantic: ({ask, context}) => {
         const nevermindType = context.type.value
@@ -94,115 +99,120 @@ const config = {
   ],
 };
 
-const getAsk = (config) => (uuid) => {
-    return (asks) => {
-    const ask = (ask, s_ids) => {
-      let oneShot = true // default
-      if (ask.oneShot === false) {
-        oneShot = false
-      }
+function getAsk(config) {
+    return (uuid) => {
+      return (asks) => {
+      function ask(ask, s_ids) {
+        let oneShot = true // default
+        if (ask.oneShot === false) {
+          oneShot = false
+        }
 
-      const id_q = stableId('semantic')
-      s_ids.push(id_q)
-      const id_rs = []
-      let wasAsked = false
-      let wasApplied = false
-      const getWasAsked = () => {
-        return wasAsked
-      }
-      const setWasAsked = (value) => {
-        wasAsked = value
-      }
-      const getWasApplied = () => {
-        return wasApplied
-      }
-      const setWasApplied = (value) => {
-        wasApplied = value
-      }
+        const id_q = stableId('semantic')
+        s_ids.push(id_q)
+        const id_rs = []
+        let wasAsked = false
+        let wasApplied = false
+        function getWasAsked() {
+          return wasAsked
+        }
+        function setWasAsked(value) {
+          wasAsked = value
+        }
+        function getWasApplied() {
+          return wasApplied
+        }
+        function setWasApplied(value) {
+          wasApplied = value
+        }
+
+        const semanticsr = ask.semanticsr || []
+        if (semanticsr.length == 0) {
+          semanticsr.push({ match: ask.matchr, apply: ask.applyr })
+        }
+        for (const semantic of semanticsr) {
+          const id_r = stableId('semantic')
+          id_rs.push(id_r)
+          s_ids.push(id_r)
+          config.addSemantic({
+            uuid,
+            id: id_r,
+            tied_ids: [id_q],
+            // tied_ids: s_ids,
+            onDelete: ask.onDelete,
+            oneShot,
+            where: semantic.where || ask.where || where(2),
+            source: 'response',
+            match: (args) => semantic.match(args),
+            apply: async (args) => {
+              setWasApplied(true)
+              await semantic.apply(args)
+            },
+          })
+        }
 
-      const semanticsr = ask.semanticsr || []
-      if (semanticsr.length == 0) {
-        semanticsr.push({ match: ask.matchr, apply: ask.applyr })
-      }
-      for (const semantic of semanticsr) {
-        const id_r = stableId('semantic')
-        id_rs.push(id_r)
-        s_ids.push(id_r)
-        // debugger
         config.addSemantic({
           uuid,
-          id: id_r,
-          tied_ids: [id_q],
+          oneShot,
+          id: id_q,
+          tied_ids: id_rs,
           // tied_ids: s_ids,
+          where: ask.where,
+          isQuestion: true,  // do one question at a time
+          getWasAsked,
+          getWasApplied,
           onDelete: ask.onDelete,
-          oneShot,
-          where: semantic.where || ask.where || where(2),
-          source: 'response',
-          match: (args) => semantic.match(args),
+          onNevermind: ask.onNevermind,
+          source: 'question',
+          match: ({ context }) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
           apply: async (args) => {
-            setWasApplied(true)
-            await semantic.apply(args)
-          },
-        })
-      }
-
-      config.addSemantic({
-        uuid,
-        oneShot,
-        id: id_q,
-        tied_ids: id_rs,
-        // tied_ids: s_ids,
-        where: ask.where,
-        isQuestion: true,  // do one question at a time
-        getWasAsked,
-        getWasApplied,
-        onDelete: ask.onDelete,
-        onNevermind: ask.onNevermind,
-        source: 'question',
-        match: ({ context }) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
-        apply: async (args) => {
-          let matchq = ask.matchq
-          let applyq = ask.applyq
-          if (!matchq) {
-            let wasAsked = false
-            matchq = () => !wasAsked,
-            applyq = (args) => {
-              wasAsked = true
-              return ask.applyq(args)
+            let matchq = ask.matchq
+            let applyq = ask.applyq
+            if (!matchq) {
+              let wasAsked = false
+              matchq = () => !wasAsked,
+              applyq = (args) => {
+                wasAsked = true
+                return ask.applyq(args)
+              }
             }
+            if (await matchq(args)) {
+              setWasApplied(false)
+              // args.context.motivationKeep = true
+              const query = await applyq({ ...args, wasAsked: getWasAsked() })
+              if (typeof query != 'string') {
+                throw new Error(`ask expects the value return from applyq to be a string. ${ask.where}`)
+              }
+              args.verbatim(query)
+              setWasAsked(true)
+              args.context.controlKeepMotivation = true
+            } else {
+              args._continue()
+            }
+            args.context.cascade = true
           }
-          if (await matchq(args)) {
-            setWasApplied(false)
-            // args.context.motivationKeep = true
-            args.verbatim(await applyq({ ...args, wasAsked: getWasAsked() }))
-            setWasAsked(true)
-            args.context.controlKeepMotivation = true
-          } else {
-            args._continue()
-          }
-          args.context.cascade = true
-        }
-      })
-    }
-    if (!Array.isArray(asks)) {
-      asks = [asks]
-    }
+        })
+      }
+      if (!Array.isArray(asks)) {
+        asks = [asks]
+      }
 
-    const s_ids = []
-    for (const a of [...asks].reverse()) {
-      // debugger
-      ask(a, s_ids)
-    }
-    
-    const cleanUp = () => {
-      config.removeSemantic(s_ids)
+      const s_ids = []
+      for (const a of [...asks].reverse()) {
+        // debugger
+        ask(a, s_ids)
+      }
+      
+      function cleanUp() {
+        config.removeSemantic(s_ids)
+      }
+      return cleanUp
     }
-    return cleanUp
   }
 }
 
 
-const initializer = ({objects, config, isModule}) => {
+function initializer({objects, config, isModule}) {
   config.addArgs(({config, api, isA}) => ({ 
     getUUIDScoped: (uuid) => { 
       const ask = getAsk(config)(uuid)
@@ -221,7 +231,7 @@ const initializer = ({objects, config, isModule}) => {
           }
 
           if (!question) {
-            const question = async ({choices, g, gs, wasAsked, state}) => {
+            async function question({choices, g, gs, wasAsked, state}) {
               if (wasAsked) {
                 return `${await g(state.lastChoice)} is not a choice. The choices are: ${await gs(choices, ' ', ' or ')}`
               } else {
@@ -231,7 +241,7 @@ const initializer = ({objects, config, isModule}) => {
           }
 
           if (!isChoice) {
-            const isChoice = ({context, choices, state}) => {
+            function isChoice({context, choices, state}) {
               state.lastChoice = context
               for (const choice of choices) {
                 if (choice.value == context.value) {