theprogrammablemind 7.1.4-beta.3

package/src/helpers.js

@@ -0,0 +1,216 @@
+const deepEqual = require('deep-equal')
+const stringify = require('json-stable-stringify')
+
+// properties - the properties that correspond to types
+// types - the expected types of the properties
+// returns list of properties found matching order of types
+
+const args = (context, hierarchy) => ({ types, properties }) => {
+  const orderedByType = []
+
+  for (const type of types) {
+    let found = false
+    for (let index = 0; index < properties.length; ++index) {
+      const value = context[properties[index]]
+      if (!value) {
+        return false
+      }
+      if (hierarchy.isA(value.marker, type)) {
+        orderedByType.push(properties[index])
+        properties.splice(index, 1)
+        found = true
+        break
+      }
+    }
+    if (!found) {
+      return
+    }
+  }
+
+  if (orderedByType.length === 0) {
+    return
+  }
+
+  return orderedByType
+}
+
+const appendNoDups = (l1, l2) => {
+  for (const x of l2) {
+    if (l1.includes(x)) {
+      continue
+    }
+    l1.push(x)
+  }
+}
+
+const safeEquals = (v1, v2) => {
+  if (!deepEqual(stringify(v1), stringify(v2))) {
+    return false
+  }
+  return true
+}
+
+/*
+const semanticsGenerate = (from, known) => {
+  const marker = from.marker
+
+  const sources = []
+  for (let key in Object.keys(from)) {
+    if (from[key].marker) {
+      sources.push(from[key])
+    }
+  }
+  const mappings = []
+  for (let key in Object.keys(to)) {
+    const source
+    if (to[keys].marker ==
+  }
+
+  return {
+    match: ({context}) => marker == marker,
+    apply: ({context}) => {
+    },
+  }
+}
+*/
+
+const hashIndexesGet = (hash, indexes) => {
+  let value = hash
+  for (const i of indexes) {
+    value = value[i]
+  }
+  return value
+}
+
+const hashIndexesSet = (hash, indexes, value) => {
+  let currentValue = hash
+  for (const i of indexes.slice(0, -1)) {
+    if (!currentValue[i]) {
+      currentValue[i] = {}
+    }
+    currentValue = currentValue[i]
+  }
+  currentValue[indexes[indexes.length - 1]] = value
+}
+
+const translationMapping = (from, to) => {
+  const mappings = []
+  for (const fkey of Object.keys(from)) {
+    if (from[fkey].value) {
+      let found = false
+      const todo = Object.keys(to).map((key) => [key])
+      while (!found) {
+        const tkey = todo.shift()
+        const tvalue = hashIndexesGet(to, tkey)
+        const fvalue = hashIndexesGet(from, [fkey])
+        if (fvalue.value === tvalue.value) {
+          mappings.push({ from: [fkey], to: tkey })
+          found = true
+          break
+        } else {
+          if (typeof tvalue !== 'string' && typeof tvalue !== 'number') {
+            for (const key of Object.keys(tvalue)) {
+              todo.push(tkey.concat(key))
+            }
+          }
+        }
+      }
+    }
+  }
+  return mappings
+}
+
+const normalizeGenerator = (generator) => {
+  if (Array.isArray(generator)) {
+    if (generator.length === 2) {
+      return { match: generator[0], apply: generator[1] }
+    } else {
+      return { match: generator[0], apply: generator[1], uuid: generator[2] }
+    }
+  }
+  return generator
+}
+
+const normalizeSemantic = (semantic) => {
+  if (Array.isArray(semantic)) {
+    if (semantic.length === 2) {
+      return { match: semantic[0], apply: semantic[1] }
+    } else {
+      return { match: semantic[0], apply: semantic[1], uuid: semantic[2] }
+    }
+  }
+  return semantic
+}
+
+const isArray = (value) => {
+  return (!!value) && (value.constructor === Array)
+}
+
+const isObject = (value) => {
+  return (!!value) && (value.constructor === Object)
+}
+
+const isCompound = (value) => {
+  return isArray(value) || isObject(value)
+}
+
+nextCallId = 0
+nextContextId = 0
+
+class InitCalls {
+
+  constructor() {
+    this.nextCallId = 0
+    this.nextContextId = 0
+    this.stack = []
+  }
+
+  start() {
+    return this.nextCallId
+  }
+
+  next() {
+    // this.nextContextId += 1
+    this.nextContextId += 1
+  }
+
+  push() {
+    this.nextCallId += 1
+    // this.nextCallId += 1
+    // this.stack.push(this.nextCallId)
+    this.stack.push(this.nextCallId)
+    const calls = this.stack.map( (call) => `call${call}` )
+    // return `Context#${this.nextContextId}: ${calls}`
+    return `Context#${nextContextId}: ${calls}`
+  }
+
+  current() {
+    return `call${this.stack[this.stack.length-1]}`
+  }
+
+  touch(context) {
+    if (!context.touchedBy) {
+      context.touchedBy = []
+    }
+    if (!context.touchedBy.includes( this.current() )) {
+      context.touchedBy.push( this.current() )
+    }
+  }
+
+  pop() {
+    this.stack.pop()
+  }
+}
+
+const hashCode = (str) => {
+  var hash = 0, i, ch;
+  if (str.length === 0) return hash;
+  for (i = 0; i < str.length; i++) {
+    ch   = str.charCodeAt(i);
+    hash  = ((hash << 5) - hash) + ch;
+    hash |= 0; // Convert to 32bit integer
+  }
+  return hash;
+};
+
+module.exports = { args, safeEquals, appendNoDups, hashIndexesGet, hashIndexesSet, translationMapping, normalizeGenerator, normalizeSemantic, isArray, isObject, isCompound, InitCalls, hashCode }

package/src/semantics.js

@@ -0,0 +1,293 @@
+const { args: contextArgs, normalizeGenerator, normalizeSemantic } = require('./helpers')
+const Lines = require('../lines')
+const sortJson = require('sort-json')
+const helpers = require('./helpers')
+
+class Semantic {
+  // constructor ({match, apply, uuid, index, km, notes}) {
+  constructor (semantic) {
+    semantic = normalizeSemantic(semantic)
+    const { match, apply, uuid, index, km, notes, priority, debug, where } = semantic
+    this.matcher = match
+    this._apply = apply
+    this.uuid = uuid
+    this.index = index
+    this.km = km
+    this.priority = priority || 0
+    this.notes = notes
+    this.callId = debug
+    this.where = where
+  }
+
+  toLabel () {
+    const where = (this.where) ? `where: "${this.where}"` : ''
+    if (!this.km) {
+      return where;
+    }
+    return `KM '${this.km}' ordinal: ${this.index} ${where}`
+  }
+
+  toString () {
+    return `Semantic(${this.matcher}, ${this._apply})`
+  }
+
+  getAPI (config) {
+    if (config && config.getAPI) {
+      return config.getAPI(this.uuid)
+    }
+  }
+
+  getAPIs (config) {
+    if (config && config._api && config._api.multiApi) {
+      return config._api.apis
+    }
+  }
+
+  matches (baseArgs, context, options = {}) {
+    const hierarchy = baseArgs.hierarchy
+    const config = baseArgs.config
+    const objects = baseArgs.getObjects(this.uuid)
+    // return this.matcher(Object.assign({}, argsBase, {args: contextArgs(context, hierarchy), objects: objects, global: objects, context: context, hierarchy: hierarchy, api: this.getAPI(config)})
+    const callId = baseArgs.calls.current()
+    const moreArgs = { 
+            uuid: this.uuid, 
+            args: contextArgs(context, hierarchy), 
+            objects: objects, 
+            global: objects, 
+            context: context, 
+            // hierarchy: hierarchy, 
+            callId,
+            api: this.getAPI(config),
+            apis: this.getAPIs(config)
+          }
+    const args = Object.assign({}, baseArgs, moreArgs)
+
+    const matches = this.matcher(args)
+    if (matches && (options.debug || {}).match
+        ||
+        callId == this.callId) {
+      debugger; // next line is the matcher
+      this.matcher(args)
+    }
+    return matches
+  }
+
+  apply (baseArgs, context, s, log, options = {}) {
+    const { hierarchy, config, response } = baseArgs
+    const objects = baseArgs.getObjects(this.uuid)
+    if (!log) {
+      console.trace()
+      throw 'log is a required argument'
+    }
+    const contextPrime = Object.assign({}, context)
+    let n = (id) => id
+    if (config && 'nsToString' in config) {
+      n = (id) => config.nsToString(id)
+    }
+    const callId = baseArgs.calls.current()
+    const moreArgs = { 
+            uuid: this.uuid, 
+            callId, 
+            args: contextArgs(context, hierarchy), 
+            objects, 
+            log, 
+            global: objects, 
+            n, 
+            context: contextPrime, 
+            uuid: this.uuid, 
+            // config, 
+            response, 
+            api: this.getAPI(config),
+            apis: this.getAPIs(config)
+    }
+    const args = Object.assign({}, baseArgs, moreArgs)
+    if ((options.debug || {}).apply
+        ||
+        callId == this.callId) {
+      debugger;
+    }
+    this._apply(args)
+    return contextPrime
+  }
+}
+
+class Semantics {
+  constructor (semantics, logs = []) {
+    semantics = semantics.map((semantic) => {
+      if (semantic instanceof Semantic) {
+        return semantic
+      } else {
+        return new Semantic(semantic)
+      }
+    })
+
+    const priorityToSemantics = {}
+    const add = (priority, value) => {
+      if (!priorityToSemantics[priority]) {
+        priorityToSemantics[priority] = []
+      }
+      priorityToSemantics[priority].push(value)
+    }
+    for (const semantic of semantics) {
+      const priority = semantic.priority
+      add(priority, semantic)
+    }
+    this.semantics = []
+    for (const key of Object.keys(priorityToSemantics).sort()) {
+      this.semantics = this.semantics.concat(priorityToSemantics[key])
+    }
+
+    this.logs = logs
+    // map ordinal to number of calls
+    this.calls = {}
+  };
+
+  getMostCalled() {
+    let maxOrdinal = 0
+    let maxCounter = 0
+    for (let ordinal in this.calls) {
+      const counter = this.calls[ordinal]
+      if (counter > maxCounter) {
+        maxOrdinal = ordinal
+        maxCounter = counter
+      }
+    }
+
+    return this.semantics[maxOrdinal]
+  }
+
+  applyToContext (args, context, options) {
+    // let context_prime = {}
+    if (!(context instanceof Array || context instanceof Object)) {
+      return context
+    }
+
+    const config = args.config
+    let contextPrime = Object.assign({}, context)
+    const s = (context, options) => this.apply(args, context, options)
+    let applied = false
+    const stack = args.calls.push()
+    let counter = 0;
+    for (const isemantic in this.semantics) {
+      const semantic = this.semantics[isemantic]
+      if (semantic.matches(args, context, options)) {
+        if (!this.calls[counter]) {
+          this.calls[counter] = 0;
+        }
+        this.calls[counter] += 1;
+        const log = (message) => { this.logs.push(message) }
+        try {
+          contextPrime = semantic.apply(args, context, s, log, options)
+        } catch( e ) {
+          contextPrime = null
+          let errorMessage
+          if (e.stack && e.message) {
+            errorMessage = `Error applying semantics '${semantic.notes}'. Error is ${e.toString()} stack is ${e.stack}. Semantic is ${semantic.toString()}`
+          } else if (e.error) {
+            errorMessage = `Error applying semantics '${semantic.notes}'. Error is ${e.error.join()}. Semantic is ${semantic.toString()}`
+          } else {
+ 						errorMessage = e.toString();
+					}
+
+          const widths = [10, 10, 90]
+          const lines = new Lines(widths)
+          lines.setElement(0, 0, 'Semantic')
+          const source = `${semantic.km}/#${semantic.index}`
+          lines.setElement(0, 2, `ERROR while applying (${source}) ${semantic.toLabel()}`)
+          lines.newRow()
+          lines.setElement(0, 2, semantic.toString())
+          lines.newRow()
+          lines.setElement(0, 1, 'TO')
+          lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(sortJson(context, { depth: 25 })))})`)
+          lines.setElement(1, 2, JSON.stringify(sortJson(context, { depth: 25 }), null, 2))
+          lines.newRow()
+          lines.setElement(0, 1, 'STACK')
+          lines.setElement(0, 2, stack)
+          lines.newRow()
+          lines.setElement(0, 1, 'DEBUG')
+          lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
+          lines.newRow()
+          lines.setElement(0, 1, 'ERROR')
+          lines.setElement(0, 2, errorMessage)
+          this.logs.push(lines.toString())
+          const message = `ERROR while applying (${source}) ${semantic.toLabel()}\n to\n ${JSON.stringify(context, null, 2)}.\n${errorMessage}'`
+          // this.logs.push(message)
+          // return [message]
+          args.calls.pop()
+          throw { error: [message], logs: this.logs }
+        }
+        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`)
+        if (((config || {}).config || {}).debug) {
+          const widths = [10, 10, 90]
+          const lines = new Lines(widths)
+          lines.setElement(0, 0, 'Semantic')
+          if (semantic.index > -1 && semantic.km) {
+            // lines.setElement(0, 2, `KM '${semantic.km}' ordinal: ${semantic.index} ${ semantic.notes ? semantic.nodes : '' }`)
+            lines.setElement(0, 2, semantic.toLabel())
+          }
+          lines.newRow()
+          lines.setElement(0, 1, 'APPLIED')
+          lines.setElement(0, 2, semantic.toLabel())
+          lines.newRow()
+          lines.setElement(0, 2, semantic.toString())
+          lines.newRow()
+          lines.setElement(0, 1, 'TO')
+          lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(sortJson(context, { depth: 25 })))})`)
+          lines.setElement(1, 2, JSON.stringify(sortJson(context, { depth: 25 }), null, 2))
+          lines.newRow()
+          lines.setElement(0, 1, 'STACK')
+          lines.setElement(0, 2, stack)
+          lines.newRow()
+          lines.setElement(0, 1, 'DEBUG')
+          lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
+          lines.newRow()
+          lines.setElement(0, 1, 'RESULT')
+          lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(sortJson(contextPrime, { depth: 25 })))})`)
+          lines.setElement(1, 2, JSON.stringify(contextPrime, null, 2))
+          this.logs.push(lines.toString())
+        }
+        applied = true
+        if (contextPrime.cascade) {
+          contextPrime.cascade = false
+        } else {
+          break
+        }
+      }
+      counter += 1
+    }
+    args.calls.pop()
+    if (!applied && ((config || {}).config || {}).debug) {
+      const widths = [10, 10, 90]
+      const lines = new Lines(widths)
+      lines.setElement(0, 0, 'Semantic')
+      lines.setElement(0, 2, 'No semantic applied')
+      lines.newRow()
+      lines.setElement(0, 1, 'TO')
+      lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(sortJson(context, { depth: 25 })))})`)
+      lines.setElement(1, 2, JSON.stringify(sortJson(context, { depth: 25 }), null, 2))
+      this.logs.push(lines.toString())
+    }
+    return contextPrime
+  }
+
+  applyToContexts (args, contexts, options) {
+    const contextsPrime = []
+    contexts.forEach((context) => {
+      contextsPrime.push(this.applyToContext(args, context, options))
+    })
+    return contextsPrime
+  }
+
+  apply (args, context, options) {
+    if (Array.isArray(context)) {
+      return this.applyToContexts(args, context, options)
+    } else if (context instanceof Object) {
+      return this.applyToContext(args, context, options)
+    } else {
+      return context
+    }
+  }
+}
+
+module.exports = { Semantic, Semantics, normalizeGenerator }

package/src/unflatten.js

@@ -0,0 +1,128 @@
+const _ = require('lodash')
+const deepEqual = require('deep-equal')
+
+const groupBy = (property, list) => {
+  const groups = {}
+  for (const element of list) {
+    if (!groups[element[property]]) {
+      groups[element[property]] = []
+    }
+    groups[element[property]].push(element)
+  }
+  return groups
+}
+
+const toList = (value) => {
+  if (value.marker === 'list') {
+    return value
+  } else {
+    return {
+      marker: 'list',
+      types: Array.from(new Set((value.types || []).concat(['list', value.marker]))),
+      value: [value]
+    }
+  }
+}
+
+const concatLists = (l1, l2) => {
+  l1 = toList(l1)
+  l2 = toList(l2)
+  return {
+    marker: 'list',
+    types: Array.from(new Set(l1.types.concat(l2.types))),
+    value: Array.from(new Set(l1.value.concat(l2.value)))
+  }
+}
+
+const findPropertyWithManyValues = (contexts, properties) => {
+  for (const property of properties) {
+    if (new Set(contexts.map( (context) => context[property] )).size == 1) {
+      return property
+    }
+  }
+}
+
+/*
+class JSONSet {
+  constructor(list = []) {
+    this.members = []
+    for (const element of list) {
+      this.add(element)
+    }
+  }
+
+  toList(element) {
+    return this.list
+  }
+
+  add(element) {
+    if (!this.has(element)) {
+      this.list.push(element)
+    }
+  }
+
+  has(searchFor) {
+    for (const element of this.list) {
+      if (!deepEqual(searchFor, element) {
+        return true
+      }
+    }
+    return false
+  }
+}
+*/
+
+// x want y and z OR       A
+// x and y want z          B
+// x wants and likes y     C
+
+const canonicalDefault = (value) => {
+	if (!value?.marker) {
+		return value;
+	}
+	return { marker: value.marker, value: value.value, word: value.wordi, types: value.types }
+}
+
+// if properties null then check the contexts for unflatten property
+const unflatten = (contexts, properties, canonical = canonicalDefault) => {
+  const grouped = {}
+  for (let context of contexts) {
+    if (!grouped[context.marker]) {
+      grouped[context.marker] = []
+    }
+    grouped[context.marker].push(context)
+  }
+  let results = []
+  for (let key in grouped) {
+    results = results.concat(unflattenHelper(grouped[key], properties || grouped[key][0].unflatten, canonical))
+  }
+  return results
+}
+
+// properties -> order of preference for grouping values, for example B,A,c
+const unflattenHelper = (contexts, properties, canonical) => {
+  if (contexts.length < 2) {
+    return contexts
+  }
+  if (!properties) {
+    return contexts
+  }
+  const groupedByMarker = groupBy('marker', contexts)
+  const unflats = []
+  for (const key in groupedByMarker) {
+    const grouping = groupedByMarker[key]
+    const groupingProp = findPropertyWithManyValues(contexts, properties)
+    const first = _.cloneDeep(grouping[0])
+    for (const next of grouping.slice(1)) {
+      for (const prop in next) {
+        if (!deepEqual(canonical(next[prop]), canonical(first[prop]))) {
+          first[prop] = concatLists(first[prop], next[prop])
+        }
+      }
+    }
+    unflats.push(first)
+  }
+  return unflats
+}
+
+module.exports = { groupBy, unflatten }