theprogrammablemind_4wp 7.5.8 → 7.6.0

package/src/flatten.js

@@ -89,7 +89,15 @@ const flatten = (markers, value) => {
   const split = markers.includes(marker)
   if (split) {
     if ('value' in properties) {
-      return [properties.value, true]
+      flattenedValues = []
+      for (let v of properties.value) {
+        if (v.flatten) {
+          flattenedValues = flattenedValues.concat(flatten(markers, v)[0])
+        } else {
+          flattenedValues.push(v)
+        }
+      }
+      return [flattenedValues, true]
     } else {
       return [[value], false]
     }

package/src/generators.js

@@ -75,7 +75,7 @@ class Generator {
 
   apply (baseArgs, objects, g, gs, context, hierarchy, config, response, log, options = {}) {
     if (!log) {
-      throw 'generators.apply argument log is required'
+      throw new Error('generators.apply argument log is required')
     }
     if (baseArgs.call && config && sbaseArgs.calls.stack.length > config.maxDepth) {
       throw new Error(`Max depth of ${config.maxDepth} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
@@ -292,7 +292,7 @@ class Generators {
         lines.setElement(0, 2, JSON.stringify(context, null, 2))
         this.logs.push(lines.toString())
       }
-      contextsPrime.push(generated)
+      contextsPrime.push((config || {}).parenthesized ? "(" + generated + ")" : generated)
     }
     return contextsPrime
   }

package/src/helpers.js

@@ -43,6 +43,16 @@ const appendNoDups = (l1, l2) => {
   }
 }
 
+const safeNoDups = (list) => {
+  noDups = []
+  for (const element of list) {
+    if (!noDups.find((e) => safeEquals(e, element))) {
+      noDups.push(element)
+    }
+  }
+  return noDups
+}
+
 const safeEquals = (v1, v2) => {
   if (typeof v1 !== typeof v2) {
     return false
@@ -53,7 +63,12 @@ const safeEquals = (v1, v2) => {
     return v1 == v2
   } else if (type == 'function') {
     return v1.toString() == v2.toString()
+  } else if (v1 == undefined || v2 == undefined) {
+    return v1 == v2
   } else {
+    if (v1.length != v2.length) {
+      return false
+    }
     for (let key in v1) {
       if (!safeEquals(v1[key], v2[key])) {
         return false
@@ -167,15 +182,13 @@ const isCompound = (value) => {
   return isArray(value) || isObject(value)
 }
 
-nextCallId = 0
-nextContextId = 0
-
 class InitCalls {
 
-  constructor() {
+  constructor(name) {
     this.nextCallId = 0
     this.nextContextId = 0
     this.stack = []
+    this.name = name
   }
 
   start() {
@@ -192,13 +205,14 @@ class InitCalls {
     // this.nextCallId += 1
     // this.stack.push(this.nextCallId)
     this.stack.push(this.nextCallId)
-    const calls = this.stack.map( (call) => `call${call}` )
+    // TODO put the nextContextId in the context for debugging
+    const calls = this.stack.map( (call) => `${this.name}#call${call}` )
     // return `Context#${this.nextContextId}: ${calls}`
-    return `Context#${nextContextId}: ${calls}`
+    return `Context#${this.nextContextId}: ${calls}`
   }
 
   current() {
-    return `call${this.stack[this.stack.length-1]}`
+    return `${this.name}#call${this.stack[this.stack.length-1]}`
   }
 
   touch(context) {
@@ -234,13 +248,17 @@ const validProps = (valids, object, type) => {
   for (let prop of Object.keys(object)) {
     let okay = false
     for (valid of valids) {
-      if (prop.match(valid)) {
-        okay = true
+      if (typeof valid == 'string') {
+        okay = prop == valid
+      } else {
+        okay = prop.match(valid)
+      }
+      if (okay) {
         break
       }
     }
     if (!okay) {
-      throw `Unknown property "${prop}" in the ${type}. Valid properties are ${valids}. The ${type} is ${JSON.stringify(object)}`
+      throw new Error(`Unknown property "${prop}" in the ${type}. Valid properties are ${valids}. The ${type} is ${JSON.stringify(object)}`)
     }
   }
 }
@@ -308,12 +326,22 @@ const functionsToStrings = (config) => {
   return config
 }
 
+const ecatch = (where, call) => {
+  try {
+    return call()
+  } catch( e ) {
+    throw new Error(`${where} ${e.stack}`)
+  }
+}
+
 module.exports = { 
+  ecatch,
   functionsToStrings,
   updateQueries,
   mapInPlace,
   validProps, 
   args, 
+  safeNoDups,
   safeEquals, 
   appendNoDups, 
   hashIndexesGet, 

package/src/project.js

@@ -0,0 +1,81 @@
+
+const project = (object, filter) => {
+  if (!object) {
+    return
+  }
+
+  let projection = {}
+  const set = (property, value) => {
+    if (value === null || value === undefined) {
+      return
+    }
+    projection[property] = value
+  }
+  if (Array.isArray(filter)) {
+    if (Array.isArray(object)) {
+      return object.map( element => project(element, filter) )
+    } else {
+      for (let properties of filter) {
+        if (typeof properties == 'object') {
+          if (properties.propertyLists) {
+            for (const propertyList in properties.propertyLists) {
+              if (object[propertyList]) {
+                for (const property of object[propertyList]) {
+                  set(property, project(object[property], properties.propertyLists[propertyList]))
+                }
+              }
+            }
+          } 
+          if (properties.valueLists) {
+            for (const listProperty in properties.valueLists) {
+              const old = object[listProperty]
+              if (Array.isArray(old)) {
+                set(listProperty, old.map((element) => project(element, properties.valueLists[listProperty])))
+              } else {
+                set(listProperty, project(old, properties.valueLists[listProperty]))
+              }
+            }
+          }
+          if (properties.properties) {
+            for (const property in properties.properties) {
+              const old = object[property]
+              set(property, project(old, properties.properties[property]))
+            }
+          }
+          if (properties.property) {
+            const property = properties.property
+            if (properties.isPropertyList) {
+              debugger
+              if (!Array.isArray(object[property])) {
+                return projection
+              }
+              for (const propertyRef of object[property]) {
+                const old = object[propertyRef]
+                set(propertyRef, project(old, properties.filter))
+              }
+            } else {
+              const old = object[property]
+              set(property, project(old, properties.filter))
+            }
+          }
+        } else {
+          if (!Array.isArray(properties)) {
+            properties = [properties]
+          }
+          for (const property of properties) {
+            set(property, object[property])
+          }
+        }
+      }
+    }
+  } else if (typeof filter == 'object') {
+    for (const property of Object.keys(filter)) {
+      set(property, project(object[property], filter[property]))
+    }
+  }
+  return projection
+}
+
+module.exports = { project }
+
+

package/src/semantics.js

@@ -6,7 +6,7 @@ class Semantic {
   // constructor ({match, apply, uuid, index, km, notes}) {
   constructor (semantic) {
     semantic = normalizeSemantic(semantic)
-    const { match, apply, uuid, index, km, notes, priority, debug, where, applyWrapped, property } = semantic
+    const { match, apply, uuid, index, km, notes, priority, debug, where, applyWrapped, property, oneShot, id } = semantic
     this.matcher = match
     this._apply = apply
     this._applyWrapped = applyWrapped
@@ -18,6 +18,8 @@ class Semantic {
     this.notes = notes
     this.callId = debug
     this.where = where
+    this.oneShot = oneShot
+    this.id = id
   }
 
   toLabel () {
@@ -89,7 +91,7 @@ class Semantic {
     // const ask = baseArgs.getAsk(this.uuid)
     if (!log) {
       console.trace()
-      throw 'log is a required argument'
+      throw new Error('log is a required argument')
     }
     const contextPrime = Object.assign({}, context)
     let n = (id) => id
@@ -197,6 +199,9 @@ class Semantics {
         const log = (message) => { this.logs.push(message) }
         try {
           contextPrime = semantic.apply(args, context, s, log, options)
+          if (!contextPrime.controlKeepMotivation && semantic.oneShot) {
+            args.config.removeSemantic(semantic)
+          }
         } catch( e ) {
           contextPrime = null
           let errorMessage
@@ -237,7 +242,7 @@ class Semantics {
           // this.logs.push(message)
           // return [message]
           args.calls.pop()
-          throw { error: [message], logs: this.logs }
+          throw { error: [message], logs: this.logs, reason: e.reason }
         }
         args.calls.touch(contextPrime)
         // this.logs.push(`Semantics: applied ${semantic.toString()}\n to\n ${JSON.stringify(context)}\n the result was ${JSON.stringify(contextPrime)}\n`)