theprogrammablemind_4wp 9.5.1 → 9.6.0

package/src/config.js

@@ -10,6 +10,7 @@ const { ecatch } = require('./helpers')
 const runtime = require('../runtime')
 const _ = require('lodash')
 const db = require('./debug')
+const { fragmentInstantiator, fragmentMapperInstantiator } = require('./fragments')
 
 const debugBreak = () => {
   // debugger
@@ -287,7 +288,7 @@ const priority_valid = (cp) => {
 const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
   ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
     () => {
-      if (bridge.development && config.isModule) {
+      if (bridge.scope && config.isModule) {
         return
       }
       if (false && !bridge.bridge) {
@@ -334,6 +335,8 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
           config.addPriority({ context: [[bridge.id, bridge.level], after], choose: [0] })
         }
       }
+
+      // done in setTestConfig
       if (bridge.check) {
         if (!config.testConfig) {
           config.testConfig = {}
@@ -344,12 +347,15 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
         if (!config.testConfig?.checks?.context) {
           config.testConfig.checks.context = []
         }
-        config.testConfig.checks.context.push({
+        config.contextChecksFromBridges.push({
+          'bridge.id': bridge.id,
+          'bridge.check': bridge.check,
           match: ({context}) => context.marker == bridge.id,
           exported: true,
           apply: ({context}) => bridge.check,
         })
       }
+
       if (bridge.after) {
         for (let before of bridge.after) {
           if (typeof before === 'string') {
@@ -399,11 +405,15 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       if (bridge.generatorp) {
         const match = bridge.generatorp.match || (() => true)
         const apply = typeof bridge.generatorp === 'function' ? bridge.generatorp : bridge.generatorp.apply || bridge.generatorp
-        const level = bridge.generatorp.level >= 0 ? bridge.generatorp.level : bridge.level + 1
+        let level = bridge.generatorp.level >= 0 ? bridge.generatorp.level : bridge.level + 1
+        if (!bridge.bridge) {
+          level = 0
+        }
 
         const generator = {
           where: bridge.generatorp.where || bridge.where || helpers.where(4),
-          match: async (args) => bridge.id === args.context.marker && args.context.level === level && args.context.paraphrase && await match(args),
+          // match: async (args) => bridge.id === args.context.marker && args.context.level === level && args.context.paraphrase && await match(args),
+          match: async (args) => args.isA(args.context.marker, bridge.id) && args.context.level === level && args.context.paraphrase && await match(args),
           apply: (args) => apply(args),
           applyWrapped: apply,
           property: 'generatorp'
@@ -420,7 +430,8 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
         const level = bridge.generatorr.level >= 0 ? bridge.generatorr.level : bridge.level + 1
         const generator = {
           where: bridge.generatorr.where || bridge.where || helpers.where(4),
-          match: async (args) => bridge.id === args.context.marker && args.context.level === level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && await match(args),
+          // match: async (args) => bridge.id === args.context.marker && args.context.level === level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && await match(args),
+          match: async (args) => args.isA(args.context.marker, bridge.id) && args.context.level === level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && await match(args),
           apply: (args) => apply(args),
           applyWrapped: apply,
           property: 'generatorr'
@@ -439,13 +450,32 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
         if (semantic.apply && typeof semantic !== 'function') {
           apply = semantic.apply
         }
-        const semanticDef = {
-          where: semantic.where || bridge.where || helpers.where(4),
-          match: (args) => bridge.id === args.context.marker && !!args.context.evaluate === evaluate && match(args),
-          apply: (args) => apply(args),
-          applyWrapped: semantic,
-          property: evaluate ? 'evaluator' : 'semantic'
+        let semanticDef
+        if (semantic.raw) {
+          if (!semantic.match) {
+            throw new Error(`In the KM "${config.name}", for the bridge ${bridge.id} the semantic is missing the "match" property.`)
+          }
+          if (!semantic.apply) {
+            throw new Error(`In the KM "${config.name}", for the bridge ${bridge.id} the semantic is missing the "apply" property.`)
+          }
+          semanticDef = {
+            match: semantic.match,
+            apply: semantic.apply,
+            applyWrapped: semantic,
+          }
+        } else {
+          semanticDef = {
+            match: (args) => bridge.id === args.context.marker && !!args.context.evaluate === evaluate && match(args),
+            apply: (args) => apply(args),
+            applyWrapped: semantic,
+          }
+        }
+        semanticDef.where = semantic.where || bridge.where || helpers.where(4)
+        semanticDef.property = evaluate ? 'evaluator' : 'semantic'
+        if (semantic.priority) {
+          semanticDef.priority = semantic.priority
         }
+
         if (addFirst) {
           config.config.semantics.unshift(addUUID(semanticDef))
         } else {
@@ -488,8 +518,43 @@ const handleCalculatedProps = (baseConfig, moreConfig, { addFirst, uuid } = {})
   if (moreConfig.bridges) {
     moreConfig.bridges = moreConfig.bridges.map((bridge) => {
       bridge = { ...bridge }
-      const valid = ['after', 'conditional', 'associations', 'before', 'bridge', 'check', 'disabled', 'development', 'skipable', 'return_type_selector', 'evaluator', 'evaluators', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'operator', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
-        'level', 'optional', 'selector', 'separators', 'semantic', 'semantics', 'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid']
+      const valid = [
+        'after', 
+        'associations', 
+        'before', 
+        'bridge', 
+        'check', 
+        'children', 
+        'conditional', 
+        'convolution', 
+        'disabled', 
+        'enhanced_associations', 
+        'evaluator', 
+        'evaluators', 
+        'generatorp', 
+        'generatorpr', 
+        'generatorr', 
+        'generators', 
+        'id', 
+        'inverted', 
+        'isA', 
+        'level', 
+        'levelSpecificHierarchy', 
+        'localHierarchy', 
+        'operator', 
+        'optional', 
+        'parents',
+        'return_type_selector', 
+        'scope', 
+        'selector', 
+        'semantic', 
+        'semantics', 
+        'separators', 
+        'skipable', 
+        'uuid',
+        'where', 
+        'words', /Bridge$/, 
+      ]
       helpers.validProps(valid, bridge, 'bridge')
       handleBridgeProps(baseConfig, bridge, { addFirst, uuid })
       return bridge
@@ -652,7 +717,7 @@ function setWordsUUIDs (words, uuid) {
   for (const key in literals) {
     literals[key] = literals[key].map((o) => Object.assign(o, { uuid }))
   }
-  const patterns = words.patterns
+  const patterns = words.patterns || []
   for (const pattern of patterns) {
     pattern.defs.map((def) => Object.assign(def, { uuid }))
   }
@@ -881,6 +946,10 @@ class Config {
     return config_toServer(config)
   }
 
+  async run(handler) {
+    return configHelpers.run(this, handler)
+  }
+
   async fixtures () {
     if (this.testConfig?.fixtures) {
       const args = {}
@@ -914,6 +983,7 @@ class Config {
 
   getPseudoConfig (uuid, config) {
     return {
+      pseudo: true,
       description: 'this is a pseudo config that has limited functionality due to being available in the initializer and fixtures function context',
       addAssociation: (...args) => this.addAssociation(...args),
       addAssociations: (...args) => this.addAssociations(...args),
@@ -927,6 +997,22 @@ class Config {
       removeSemantic: (...args) => this.removeSemantic(...args, uuid, config.name),
       addWord: (...args) => this.addWord(...args, uuid),
       addPattern: (...args) => this.addPattern(...args, uuid),
+      updateBridge: (...args) => this.updateBridge(...args),
+      processContext: (...args) => this.processContext(...args),
+
+      semantics: () => this.config.semantics,
+      getConfigs: () => this.configs,
+      getTestConfig: () => this.getTestConfig(),
+      getTests: () => this.getTests(),
+      getName: () => this.getName(),
+      getDescription: () => this.getDescription(),
+      getDebug: () => this.getDebug(),
+      getDebugLoops: () => this.getDebugLoops(),
+      getMaxDepth: () => this.getMaxDepth(),
+      getAPIs: (...args) => this.getAPIs(...args),
+      getAPI: (...args) => this.getAPI(...args),
+      getUUID: (...args) => this.getUUID(...args),
+      nsToString: (...args) => this.nsToString(...args),
 
       getHierarchy: (...args) => this.config.hierarchy,
       getBridges: (...args) => this.config.bridges,
@@ -936,10 +1022,53 @@ class Config {
       fragment: (...args) => this.fragment(...args),
       server: (...args) => this.server(...args),
       exists: (...args) => this.exists(...args),
-      addAPI: (...args) => this.addAPI(...args)
+      addAPI: (...args) => this.addAPI(...args),
+
+      getParenthesized: () => this.getParenthesized(),
+      setParenthesized: (...args) => this.setParenthesized(...args),
     }
   }
 
+  getUUID() {
+    return this.uuid
+  }
+
+  getTestConfig() {
+    return this.testConfig
+  }
+
+  getMaxDepth() {
+    return this.config.maxDepth
+  }
+
+  getDebug() {
+    return this.config.debug
+  }
+
+  getDebugLoops() {
+    return this.config.debugLoops
+  }
+
+  getName() {
+    return this.name
+  }
+
+  getDescription() {
+    return this.description
+  }
+
+  getTests() {
+    return this.tests
+  }
+
+  getParenthesized(value) {
+    return this.parenthesized
+  }
+
+  setParenthesized(value) {
+    this.parenthesized = value
+  }
+
   inDevelopmentMode (call) {
     config.developmentModeOn += 1
     try {
@@ -956,7 +1085,27 @@ class Config {
   }
 
   setTestConfig (testConfig) {
-    this.testConfig = testConfig
+    this.testConfig = { ...testConfig }
+    if (!this.testConfig.checks) {
+      this.testConfig.checks = {}
+    }
+    if (!this.testConfig?.checks?.context) {
+      this.testConfig.checks.context = []
+    }
+    this.testConfig.checks.context = this.contextChecksFromBridges.concat(this.testConfig.checks.context)
+    /*
+    const currentTestConfig = testConfig // add bridge has added check.context's
+
+    if (!this.testConfig.checks) {
+      debugger
+      // this.testConfig.checks = 
+    }
+
+    // set during bridge setup
+    if (currentTestConfig.checks?.context) {
+      this.testConfig.checks.context = currentTestConfig.checks.context.concat(this.testConfig.checks.context)
+    }
+    */
   }
 
   getTestConfig () {
@@ -1086,59 +1235,52 @@ class Config {
     return instance
   }
 
-  fragmentInstantiator (args, contexts) {
-    return new Object({
-      contexts: () => contexts,
-      instantiate: async (mappings) => {
-        const instantiated = _.cloneDeep(contexts)
-        // const todo = [...instantiated]
-        // const todo = [...instantiated]
-        const todo = _.clone(instantiated)
-        args = { ...args }
-        while (todo.length > 0) {
-          const context = todo.pop()
-          args.context = context
-          for (const mapping of mappings) {
-            if (await mapping.match(args)) {
-              await mapping.apply(args)
-            }
-          }
-          for (const key of Object.keys(context)) {
-            // if (['number', 'string', 'boolean'].includes(typeof (context[key]))) {
-            if (!helpers.isCompound(context[key])) {
-              continue
-            }
-            if (context[key].instantiated) {
-              continue
-            }
-            todo.push(context[key])
-          }
-        }
-        return instantiated
-      }
-    })
-  }
-
-  fragment (args, query) {
+  getFragment(query) {
     for (const instance of (this.instances || [])) {
       for (const fragment of (instance.fragments || [])) {
         if (fragment.query === query) {
-          return this.fragmentInstantiator(args, fragment.contexts)
+          return fragment
         }
       }
       for (const fragment of (instance.resultss || [])) {
         if (fragment.isFragment && fragment.query === query) {
-          return this.fragmentInstantiator(args, fragment.contexts)
+          return fragment
         }
       }
       for (const fragment of (this.fragmentsBeingBuilt || [])) {
         if (fragment.query === query) {
-          return this.fragmentInstantiator(args, fragment.contexts)
+          return fragment
         }
       }
     }
   }
 
+  // mappings are optional
+  async fragment (args, query, mappings) {
+    const fragment = this.getFragment(query)
+    if (fragment) {
+      let fi = fragmentInstantiator(args, fragment.contexts)
+      if (mappings) {
+        fi = await fi
+        return fi.instantiate([{
+          match: ({context}) => !!mappings[context.value], // is the value in the mappings
+          apply: ({context}) => Object.assign(context, mappings[context.value]),
+        }])
+      } else {
+        return fi
+      }
+    }
+  }
+
+  fragmentMapper (args, values, fromModelQuery, toModelQuery) {
+    const fromModelFragment = this.getFragment(fromModelQuery)
+    console.dir(fromModelFragment)
+    const toModelFragment = this.getFragment(toModelQuery)
+    console.dir(toModelFragment)
+    const mapper = fragmentMapperInstantiator(values, fromModelFragment.contexts, toModelFragment.contexts)
+    return mapper
+  }
+
   // { rebuild: false, isModule: false }
   needsRebuild (template, instance, options) {
     if (options.rebuild) {
@@ -1497,6 +1639,11 @@ class Config {
     }
   }
 
+  updateBridge(id, updater) {
+    const bridge = this.config.bridges.find((b) => b.id === id)
+    updater({ config: this, bridge })
+  }
+
   addBridge (bridge, uuid) {
     if (!this.config.bridges) {
       this.config.bridges = []
@@ -1681,7 +1828,9 @@ class Config {
 
   getAPIs (uuid) {
     let config
-    if (this._uuid === uuid) {
+    if (!uuid) {
+      config = this
+    } else if (this._uuid === uuid) {
       config = this
     } else {
       for (const km of this.configs) {
@@ -1696,6 +1845,14 @@ class Config {
     }
   }
 
+  /*
+  getAPIs (config) {
+    if (config && config._api && config._api.multiApi) {
+      return config._api.apis
+    }
+  }
+  */
+
   getServer () {
     return this._server
   }
@@ -1798,7 +1955,7 @@ class Config {
 
   // set the args in the api's
   setArgs (args) {
-    const setArgs = (config) => {
+    const setConfigArgs = (config) => {
       if (!config._api) {
         return
       }
@@ -1811,10 +1968,10 @@ class Config {
       }
     }
 
-    setArgs(this)
+    setConfigArgs(this)
     for (const config of this.configs) {
       if (config.config instanceof Config) {
-        setArgs(config.config)
+        setConfigArgs(config.config)
       }
     }
   }
@@ -1843,6 +2000,16 @@ class Config {
     }
   }
 
+  getObjects () {
+    const configs = {}
+    const ns = this.config.objects.namespaced
+    configs[this.name] = this
+    for (const config of this.configs) {
+      configs[config._name] = ns[config._uuid]
+    }
+    return configs
+  }
+
   getConfig (name) {
     if (this.name === name) {
       return this
@@ -1867,20 +2034,68 @@ class Config {
     return kms
   }
 
+  // scope == 'testing' -> remove none
+  // scope == 'development' -> remove testing
+  // !scope -> remove 'testing' and 'development'
   removeDevelopmentElements (config) {
     if (!config) {
       return
     }
-    config.operators = config.operators.filter((element) => !element.development)
-    config.bridges = config.bridges.filter((element) => !element.development)
-    config.generators = config.generators.filter((element) => !element.development)
-    config.semantics = config.semantics.filter((element) => !element.development)
-    config.hierarchy = (config.hierarchy).filter((element) => !element.development)
+
+    const idToScope = {}
+    for (const bridge in config.bridges) {
+      if (bridge.scope) {
+        idToScope[bridge.id] = scope
+      }
+    }
+    
+    const keep = (element) => {
+      const old_result = element.scope !== 'testing'
+      let new_result = false
+      if (!this.scope) {
+        new_result = !(element.scope === 'testing' || element.scope == 'development')
+      } else if (this.scope == 'development') {
+        new_result = !(element.scope === 'testing')
+      }
+      return new_result
+    }
+
+    config.operators = config.operators.filter((element) => keep(element))
+    config.bridges = config.bridges.filter((element) => keep(element))
+    config.generators = config.generators.filter((element) => keep(element))
+    config.semantics = config.semantics.filter((element) => keep(element))
+
+    // account for element missing correct scope
+    config.hierarchy = (config.hierarchy).filter((element) => {
+      if (!keep(element)) {
+        return false
+      }
+      const discard = (id) => {
+        if (idToScope[id]) {
+          return !keep({ scope: idToScope[id] })
+        }
+      }
+      if (element.child && discard(element.child)) {
+        return false
+      }
+      if (element.parent && discard(element.parent)) {
+        return false
+      }
+      if (Array.isArray(element)) {
+        if (discard(element[0])) {
+          return false
+        }
+        if (discard(element[1])) {
+          return false
+        }
+      }
+      return true
+    })
 
     const literals = config.words.literals
     for (const word in literals) {
       const defs = literals[word] || []
-      literals[word] = defs.filter((def) => !def.development)
+      literals[word] = defs.filter((def) => keep(def))
       if (literals[word].length === 0) {
         delete literals[word]
       }
@@ -1890,7 +2105,7 @@ class Config {
     const patternsPrime = []
     for (const pattern of patterns) {
       let defs = pattern.defs || []
-      defs = defs.filter((def) => !def.development)
+      defs = defs.filter((def) => keep(def))
       if (defs.length !== 0) {
         patternsPrime.push({ ...pattern, defs })
       }
@@ -1900,7 +2115,7 @@ class Config {
     const hierarchy = config.words.hierarchy || []
     const hierarchyPrime = []
     for (const pair of hierarchy) {
-      if (!pair.development) {
+      if (keep(pair)) {
         hierarchyPrime.push(pair)
       }
     }
@@ -1925,7 +2140,7 @@ class Config {
   }
 
   // configs = [ { config, namespace } ... ]
-  constructor (config, module, clientProcess, apiKMs) {
+  constructor (config, module, clientProcess, apiKMs, rootIsProcess, testingModuleName) {
     if (config instanceof Config) {
       throw new Error('Excepted the config argument to be a hash not a Config object')
     }
@@ -1947,6 +2162,8 @@ class Config {
       config.priorities = config.priorities || []
     }
 
+    this.contextChecksFromBridges = []
+
     this._enable = []
     this._apiKMs = apiKMs
 
@@ -1965,9 +2182,26 @@ class Config {
         this.loadedForTesting = true
       }
     }
+    if (config) {
+      this.name = config.name
+    }
     this.isModule = !isProcess
+    this.scope = null
+    this.rootIsProcess = rootIsProcess
+    this.testingModuleName = testingModuleName
     if (this.isModule) {
+      if (rootIsProcess) {
+        if (testingModuleName == this.name) {
+          this.scope = 'testing'
+        } else {
+          this.scope = 'development'
+        }
+      }
       this.removeDevelopmentElements(config)
+    } else {
+      if (testingModuleName == this.name) {
+        this.scope = 'testing'
+      }
     }
     this.initInstances = []
     this.instances = []
@@ -1989,7 +2223,7 @@ class Config {
 
     // set the default server so stuff just works
     // this.server('https://184.67.27.82:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
-    this.server('https://thinktelligence.com:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
+    this.server('https://thinktelligence.com/entodicton', '6804954f-e56d-471f-bbb8-08e3c54d9321')
 
     this.defaultConfig()
     this.initializerFn = ({ currentConfig }) => {
@@ -1998,9 +2232,6 @@ class Config {
       }
     }
     this.terminatorFn = () => {}
-    if (config) {
-      this.name = config.name
-    }
     this.loadOrder = new DigraphInternal()
     this.wasInitialized = false
     this.configs = []
@@ -2259,6 +2490,7 @@ class Config {
     // update uuid here set the uuid in the objects and add error checking
     cp.initializerFn = this.initializerFn
     cp.terminatorFn = this.terminatorFn
+    cp.contextChecksFromBridges = this.contextChecksFromBridges
     cp._apiKMs = this._apiKMs
     cp._apiConstructor = this._apiConstructor
     if (cp._apiConstructor) {
@@ -2290,6 +2522,10 @@ class Config {
     cp.hierarchy = new DigraphInternal(this.config.hierarchy)
     cp.sendObjectsToServer = this.sendObjectsToServer
 
+    cp.scope = this.scope
+    cp.rootIsProcess = this.rootIsProcess
+    cp.testingModuleName = this.testingModuleName
+
     cp.initConfig = _.cloneDeep(this.initConfig)
     cp.defaultConfig()
     // cp.wasInitialized = false;  // since default config GREG
@@ -2615,19 +2851,37 @@ class Config {
 
   getContextChecks() {
     const allChecks = []
-    for (const name of this.loadOrdering) {
-      const checks = this.kms[name].testConfig?.checks?.context || []
-      for (const check of checks) {
-        if (check.exported) {
-          allChecks.push(check)
+    let defaults = () => []
+    if (this.loadOrdering) {
+      for (const name of this.loadOrdering) {
+        const checks = this.kms[name].testConfig?.checks?.context || []
+        const oldDefaults = defaults
+        for (const check of checks) {
+          if (!check.match) {
+            const oldDefaults = defaults
+            defaults = () => helpers.safeNoDups([...check.apply(), ...oldDefaults()])
+            continue
+          }
+          if (check.exported) {
+            allChecks.push(check)
+          }
         }
       }
     }
     for (const check of this.testConfig?.checks?.context || []) {
+      if (!check.match) {
+        const oldDefaults = defaults
+        defaults = () => [...new Set([...check.apply(), ...oldDefaults()])]
+        continue
+      }
       if (!check.exported) {
         allChecks.push(check)
       }
     }
+    allChecks.push({
+      match: () => true,
+      apply: defaults
+    })
     return allChecks
   }
 
@@ -3144,7 +3398,7 @@ class Config {
 
     const mores = []
     for (const createConfig of createConfigs) {
-      const more = await createConfig()
+      const more = await createConfig({ rootIsProcess: this.rootIsProcess, testingModuleName: this.testingModuleName })
       if (this.name && this.name === more.name) {
         throw new Error('Cannot add an object to itself for argument number ${index+1}.')
       }