godprotocol 1.1.32 → 1.2.0

package/callables/functions/assert.js

@@ -0,0 +1,10 @@
+const assert = async(args, {vm})=>{
+  let {predicate} = args;
+
+  let yes = !!await predicate.literal()
+
+  if (yes) return;
+  return await vm.throw_error({type: 'AssertionError', message: 'Test case failed!'})
+}
+
+export default assert

package/callables/functions/display.js

@@ -6,12 +6,11 @@ const display = async (args) => {
   let lit= new Array()
   for(let d =0; d < data.length; d++){
     let tum = data[d]
-    lit.push(await tum.literal())
+    let v = tum && await tum.literal()
+    lit.push(v)
   }
 
   console.log(...lit)
-
-  return 0
 };
 
 export default display;

package/callables/functions/env.js

@@ -0,0 +1,5 @@
+const env = async(args, {vm, thread})=>{
+  return vm.envs[thread._id]
+}
+
+export default env;

package/callables/functions/event.js

@@ -0,0 +1,14 @@
+const listen = async(args_, vm)=>{
+  let {name, handler} = args_
+  
+}
+
+const emit = async(args_, vm)=>{
+  let {name, args, key} = args_
+
+  let res = await vm.account.emit(await name.literal(), args.to_address(), await key.literal())
+
+  return res;
+}
+
+export {listen, emit}

package/callables/functions/exit.js

@@ -2,9 +2,10 @@ const quit = async(args, vm)=>{
   let {code} = args;
   if (code) code = await code.literal()
 
-  console.log(`Program exit with code:${code ||0}`)
+  let msg = `Program exit with code:${code ||0}`
+  console.log(msg)
 
-  return {exit: true, code}
+  return await vm.throw_error({type: 'KeyBoardInterrupt', message: msg})
 }
 
 export default quit

package/callables/functions/folder.js

@@ -0,0 +1,15 @@
+const folder = async(args, {vm, chain})=>{
+  let {name, options} = args
+  name = await name.literal()
+  options = options && await options.literal()
+  let {physical_address, manager} = vm.account;
+
+  let fold = await manager.gds.folder(`${physical_address}/${name}`, {...options, repos: physical_address})
+
+  fold = await vm.folder(fold)
+  let acc_fold = await chain.write(fold, {raw: true})
+
+  return acc_fold
+}
+
+export default folder

package/callables/functions/get_uid.js

@@ -0,0 +1,6 @@
+const get_uid = (args, {vm})=>{
+  // console.log(args.object)
+  return args.object.config.uid
+}
+
+export default get_uid

package/callables/functions/hash.js

@@ -0,0 +1,7 @@
+const hash = async(args, {vm})=>{
+  let object = await args.object.literal()
+
+  return await vm.account.vm.hash(object)
+}
+
+export default hash

package/callables/functions/import_.js

@@ -0,0 +1,62 @@
+const import_ = async(args, {vm, chain, thread})=>{
+  let {address, identifiers} = args, account = vm.account;
+  address = await address.literal()
+  identifiers = identifiers && await identifiers.literal()
+  
+  console.log(address, identifiers)
+  if (address.startsWith('@/')) 
+    address = address.slice(2)
+
+  let res = await account.run({
+    address,
+    thread:{_id: thread._id, pointer: thread.pointer}
+  , callback: async(res)=>{
+    
+    let id = Array.isArray(identifiers) ? [...identifiers] : [identifiers]
+
+    let twa = {}    
+    for (let i=0; i< id.length; i++){
+      let iden = id[i]
+      for (let r=res.length-1; r>=0; r--){
+        let obj = res[r]
+        if (!obj) continue;
+        if (obj.type === 'address'){
+          if (obj.identifier === iden){
+            twa[iden] = obj;
+          }
+        }else if (obj.type === 'function'){
+          if (obj.address.endsWith(`/${iden}`)){
+            twa[iden] = obj
+          }
+        }
+        if (twa[iden]) break;
+      }
+      if (!twa[iden]) {
+        thread.results[thread.pointer-1] = await vm.throw_error({
+          type:"ImportError",
+          message: `No export - ${iden}`
+        })
+        return
+      }
+    }
+    let result = twa[id[0]]
+    if (Array.isArray(identifiers)){
+      let actual_twain = {type:'twain', value: {}, location: await vm.gen_location()}
+      for (let prop in twa){
+        let res = await vm.instantiate({
+          type: 'string',
+          value: prop, 
+          location: await vm.gen_location()
+        }, {chain})
+
+        actual_twain.value[await vm.hash(prop, 'sha1')] = [res, twa[prop]]
+      }
+      result = await vm.instantiate(actual_twain, {chain})
+    }
+    
+    thread.results[thread.pointer-1] = result
+  }}) 
+}
+
+
+export default import_

package/callables/functions/local.js

@@ -0,0 +1,9 @@
+const local = async(args_, {vm, chain})=>{
+  let {name_address, arguments: args} = args_;
+
+  name_address = await name_address.literal()
+  args = args && await args.literal()
+  console.log(name_address, args, "LOCAL")
+}
+
+export default local

package/callables/functions/net.js

@@ -1,26 +1,41 @@
-import { post_request } from "../../utils/services";
+import { gen_random_int } from "generalised-datastore/utils/functions.js";
+import { post_request } from "../../utils/services.js";
 
-const net = async(args, vm, options={})=>{
-  let {chain, config} = options;
-  let {server, path, payload, callback} = args;
-  
-  server = await server.literal()
-  path = await path.literal()
-  if (!path.startsWith('/')) path = `/${path}`
+const net = async(args, {vm, chain, call_config, thread})=>{
+  let {server, path, account, payload} = args;
 
-  payload = payload && await payload.literal()
+  thread.status = 'waiting'
+  path = await path.literal()
+  payload = await payload.literal()
+  let serv = server && [await server.literal()];
+  account = account ? await account.literal() : vm.account.name
+  if (!serv){
+    serv = await vm.account.manager.oracle.get_servers(`Accounts/${account}`)
+  }
 
-  let result;
-  if(callback){
+  let s = gen_random_int(serv.length-1)
+  let servr = serv[s]
 
-  }else {
-    result = await post_request({options: {hostname: server.ip, port: server.port, path}, data: payload})
-    
-    result = await vm.parse_dynamic(result, {chain, config})
-  }
-  
+  post_request({
+    options: {
+      hostname: servr.hostname,
+      port: servr.port,
+      path: `/${path}`,
+      method: payload.header.method.toUpperCase(),
+      headers: {
+        ...payload.header
+      }
+    },
+    data: payload.body && JSON.stringify(payload.body)
+  }).then(async res=>{
+    let adr = await vm.parse_aircode(res, {chain})
+    thread.results[thread.pointer-1] = adr;
+    thread.status = 'active'
+  }).catch(e=>{
+    console.log(e)
+  })
 
-  return result;
+  return;
 }
 
 

package/callables/functions/parse.js

@@ -0,0 +1,35 @@
+const parse = async(args, {vm})=>{
+  let {address, options} = args;
+
+  address = await address.literal()
+  options = await options.literal()
+
+  let mgr = vm.account.manager
+  let account = await mgr.get_account(options.account || vm.account.name)
+
+  let full_address = `${account.physical_address}/${address}`
+  let folder = await mgr.ds.folder(full_address)
+  let conf_folder = await folder.folder('.configs')
+
+  let config_query = options.config_query || {}
+  let query = options.query || {}
+  let conf = await conf_folder.readone(config_query.query, config_query.options), result;
+
+  if (['class', 'function'].includes(conf.type)){
+    result = {
+      type: 'function', 
+      address: conf.address,
+      _id: conf._id
+    }
+  } else if(conf.type === 'instance'){
+    
+  } else if (conf.type === 'module'){
+
+  }else if (conf.type === 'variable') {
+    result = await folder.readone(query.query, query.options)
+  }
+
+  return result
+}
+
+export default parse;

package/callables/functions/query.js

@@ -0,0 +1,12 @@
+const query = async(args, {vm, thread}) => {
+  let {object, filter} = args;
+
+  object = await object.literal()
+  filter = await filter.literal()
+
+  let res = await vm.account.chain.folder().pass(object, filter)
+  
+  return res;
+}
+
+export default query

package/callables/functions/render.js

@@ -1,23 +1,19 @@
-const render = async (args, { vm, config, chain }) => {
-  let { object } = args;
-
-  let res = await object.get("render");
-  if (!res) return null;
+const render = async (args, { vm, config, uid, chain }) => {
+  let { object, query_selector, parent } = args;
 
+  let res = await object.get('__render__')
   let result = await vm.execute(
     {
       type: "call",
-      identifier: {
-        type: "address",
-        value: res,
-        object: object.value.path,
-      },
-      arguments: [],
-      location: config.location,
+      identifier: res,
+      arguments: parent ? [{ type: "address", value: parent.path }] : [],
+      location: config.location || `${chain.physical_address}/_render`,
     },
-    { chain }
+    { chain, uid: object.config.uid }
   );
 
+  console.log(result)
+  await object.set_("__config__", result);
   return result;
 };
 

package/callables/functions/servers.js

@@ -0,0 +1,10 @@
+const servers = async(args, {vm})=>{
+  let account = await args.account.literal()
+  
+  account = vm.account.manager.get_account(account);
+  if (!account)return []
+
+  return await account.get_servers()
+}
+
+export default servers

package/callables/functions/spawn.js

@@ -0,0 +1,7 @@
+const spawn = async (args, {vm, chain})=>{
+  let {spawn} = args;
+
+  await spawn.invoke([], {no_wait: true, chain})
+}
+
+export default spawn

package/callables/functions/store.js

@@ -0,0 +1,75 @@
+const addresses = new Object()
+
+const retrieve = async(args, {vm, chain})=>{
+  let {address, _id} = args;
+
+  address = await address.literal()
+  _id = _id && await _id.literal()
+
+  let res = await vm.account.parse({address, _id, retrieve: true})
+
+  return res;
+}
+
+const store = async(args, {vm, chain, thread})=>{
+  if (!addresses) addresses = new Object() 
+  let {object} = args;
+
+  let config = object.config, data, address = config.location;
+  let id = `${address}-${config._id}`
+  
+  let exists = addresses[id]
+  
+  if(exists){
+    if (exists.updated >= config.updated){
+      return
+    }
+  }
+  addresses[id]  = {...config}
+
+  switch(config.type){
+    case 'instance':
+      if (config.methods.__store__){
+        let spli = vm._split_datapath(config.methods.__store__)
+        await object.run({identifier: {value: spli[0], _id: spli[1]}, arguments:[]}, {chain, thread})
+      }
+      
+      break;
+    case 'string':
+      address = config.location
+      break;
+    case 'number':
+      address = config.location
+      break;
+    case 'array':
+      data = await object.store({store, thread})
+      break;
+    case 'twain':
+      data = await object.store({store, thread})
+      break;
+    default:
+      console.log(config, "DFAULT")
+      data = await object.to_address()
+      console.log(data)
+      return;
+  }
+
+  if(!address)return;
+
+  let ds = vm.account.manager.ds
+  let folder = await ds.folder(address, {account: vm.account.physical_address})
+  let res = await folder.write(data || config, {replace: true})
+
+  if (config.type === 'instance'){
+    let class_account = config.cls.split('/').slice(0,2).join('/')
+    let class_folder_account = await (await ds.folder(config.cls)).folder(`${vm.account.physical_address}`, {account: class_account})
+    await class_folder_account.write({
+      _id: config._id,
+    })
+  }
+
+  return data || config
+}
+
+export default store;
+export {retrieve}

package/callables/functions/super_.js

@@ -0,0 +1,24 @@
+const super_ = async(args, {vm, call_config, thread, chain})=>{
+  let {object} = args
+
+  if (object.config.inherited.includes(call_config.cls)){
+    console.warn('Cyclic inheritance, truncating now!', call_config.cls)
+    return;
+  }else {
+    console.log(call_config.cls)
+    object.config.inherited.push(call_config.cls)
+    await (await vm.account.manager.ds.folder(object.config.location)).write(object.config, {replace: true})
+  }
+
+  let cls = await vm.variable(call_config.cls, {chain, obj: true})
+
+  let args_ = []
+  for (let a in args.args){
+    if (a=='object') continue
+    args_.push(await args.args[a].to_address())
+  }
+
+  await cls.run_init({vm, args: args_, ins: await object.to_address(), thread})
+}
+
+export default super_

package/callables/functions/typeof.js

@@ -0,0 +1,32 @@
+const type_of = (args, {vm})=>{
+  let {object} = args;
+
+  return object.type
+}
+
+const instance_of = async(args, {vm})=>{
+  let {object} = args;
+
+  let result;
+  if (vm.datatypes.includes(object.type)){
+    result = {
+      type: 'address',
+      value: object.type,
+      _id: object.type,
+      config: true
+    }
+  }else if(['class', 'function'].includes(object.type)){
+    result = await vm.voided()
+  }else if (object.type === 'instance'){
+    result = {
+      type: 'function',
+      address: object.config.cls,
+      _id: object.config.cls_id,
+    }
+  }
+
+  return result;
+}
+
+export default type_of
+export {instance_of}

package/callables/functions/wait.js

@@ -0,0 +1,9 @@
+const wait = async(args, {vm, thread})=>{
+  let {duration} = args;
+
+  duration = await duration.literal()
+
+  thread.status = {duration, start: Date.now()}
+}
+
+export default wait