godprotocol 1.0.842 → 1.1.0

package/Executables/callables.js

@@ -0,0 +1,131 @@
+class Callables{
+  constructor(){
+    this.callables = new Object()
+  }
+
+  prepare_callable_args = (config, payload)=>{
+
+    let {arguments:args} = payload;
+    let {argv} = args;
+
+    let arg_obj = {}, spreading;
+
+    for (let a=0;a< argv.length;a++){
+      let arg = argv[a]
+
+      let param, content = arg.static_value || this.read_chain(arg.address)
+      if(spreading){
+        arg_obj[spreading].push(content)
+      } else {
+        if (arg.name){
+          arg_obj[arg.name] = content;
+          param = config.parameters.find(p=>p.name === arg.name)
+        }else {
+          param = config.parameters[arg.position]
+          if(!param)continue
+          arg_obj[param.name] = content
+        }
+
+        if (param.spread){
+          spreading = param.name;
+          arg_obj[spreading] = [arg_obj[spreading]]
+        }
+      }
+    }
+
+    return arg_obj
+  }
+
+  callable = (payload)=>{
+    let {executable, metadata, location} = payload;
+    if (!metadata)metadata = {}
+
+    let call = this.callables[executable];
+    if(!call)return this.stderr(`Callable:${executable} is not set`)
+
+    let callable = call.callable;
+    let config = call.config
+
+    if (typeof callable !== 'function') return this.stderr(`Callable:${executable} must be a callable type.`)
+
+
+    let args;
+    if (config) {
+      args = this.prepare_callable_args(config, payload)
+    }
+
+    let result = callable(args, this, {...payload, location})
+    if (!metadata.raw )
+    result && this.write_chain(result.result,result.address|| location, {is_callable: result.is_callable})
+
+    return metadata.raw ? result : {
+      estimated_time: '-ms',
+      callback: location
+    }
+  }
+
+  write_chain = (result, location, options)=>{
+    if (result==null)return
+    let {is_callable}=options || {};
+
+    let loc_chain = this.handle_chain(location)
+  
+    if(is_callable){
+      loc_chain.set_obj_config(result)
+    }else {
+      loc_chain.forge_block({metadata: {output: this.account.save(result)}})
+    }
+  }
+
+  add_callable = (name, callable_config)=>{
+    this.callables[name] = callable_config
+  }
+
+  composite_depth = 3
+
+  display = (values, options )=>{
+    let {buff, depth, include_address} = options || {}, value;
+    if (!buff) buff =  new Object()
+   
+    if (!values)return values
+    
+    if (values.__print__ ){
+       let stat = this.static_value(values, true)
+      if(!stat)return values;
+      value = stat
+    }else value = values
+
+    let hash = this.account.manager.oracle.hash(value);
+    if (buff[hash]) return buff[hash]
+
+    if(value.type === 'array'){
+      let arr = []
+      for (let a=0; a< value.static_value.length; a++){
+        arr.push(this.display(this.read_chain(value.static_value[a]), {buff}))
+      }
+      value = arr;
+    }else if (value.type === 'twain'){
+      let keys = Object.keys(value.static_value)
+      let obj = {}
+      for (let s=0; s< keys.length; s++){
+        let key = keys[s]
+        let pair = value.static_value[key]
+        
+        let prop = this.display(this.read_chain(pair[0]), {buff})
+
+        obj[prop] = this.display(this.read_chain(pair[1]), {buff})
+      }
+      value = obj
+    }else if (['string', 'number', 'boolean'].includes(value.type)){
+      value = value.static_value
+    }else value = (value && value.__address__) || value
+
+    buff[hash] = value;
+    
+    if (depth == null){
+      return value;
+    }
+  }
+}
+
+export default Callables

package/Executables/executables.js

@@ -0,0 +1,230 @@
+import { generate_random_string } from "generalised-datastore/utils/functions";
+import Callables from "./callables";
+import Stack from "./stack";
+import { post_request } from "godprotocol/utils/services";
+
+
+class Executables extends Callables{
+  constructor(){
+    super()
+
+    this.stack = new Stack(this)
+  }
+
+  exec = (request)=>{
+    let payload = request.op0 || request;
+
+    let {executable, url_callback, location} = payload;
+    console.log(request)
+    
+    if (!executable && request.op1) executable = request.op1.static_value
+
+    if(typeof executable !== 'string' && executable){
+      executable = executable.static_value || executable.__address__
+    }
+    if(!executable)return this.stderr({name: 'Call_error', message:"Executable cannot be undefined"})
+
+    if (!executable.includes('/')){
+      let result = this.callable(payload)
+      if (url_callback) post_request({options:url_callback, data: result})
+      return result
+    }
+
+    if(executable.includes('undefined')){
+      console.log(executable)
+      let err_obj = {name:'Type_error', message: `executable cannot have an undefined config`}
+      return this.stderr(err_obj)
+    }
+
+    // console.log(payload)
+    let config = this.get_config(executable)
+    if (!config){
+      return this.stderr({name:'Name_error', message:'Callable config not existing'})
+    }
+
+    switch(config.type){
+      case "class":
+        this.execute_class(config, payload)
+        break;  
+      case "function":
+        this.execute_function(config, payload)
+        break;
+      case "module":
+        this.execute_module(config, payload)
+        break;
+      default:
+        this.stderr(`Unknown call type`)  
+      ;
+    }
+
+    return {
+      estimated_time: `-ms`,
+      callback: location,
+    }
+  }
+
+  execute_class = (config, payload)=>{
+    let {methods, base_classes} = config;
+    let {location, local_address, url_callback, executable} = payload;
+
+    let object = {__classifier__:executable, __type__: `${this.account.physical_address}/CONSTANTS/types/instance`}
+    let object_id = generate_random_string(12, 'alnum')
+    object.__id__ = object_id
+
+    let real_path = `${local_address || location}_${object_id}`
+    let object_chain = this.handle_chain(real_path)
+
+    let location_height = object_chain.height;
+
+    for (let b=0; b< base_classes.length; b++){
+      let cls = base_classes[b]
+      let cls_config = this.get_config(cls);
+
+      if(!cls_config || (cls_config && cls_config.type !== 'class')){
+        return this.stderr(`Base must be a 'class' type`)
+      }
+
+      let {methods: b_methods} = cls_config;
+      for(let name in b_methods){
+        let method_addr = b_methods[name]
+
+       this.handle_method_config({name, method_addr, object, location: real_path, location_height}) 
+      }
+    }
+    for(let name in methods){
+      let method_addr = methods[name]
+
+      this.handle_method_config({name, method_addr, object, location: real_path, location_height})
+    }
+    
+    object.__address__ = real_path;
+
+    object_chain.forge_block({metadata:{output: this.account.save(object)}})
+
+    if (object.__init__){
+      this.execute_function(this.get_config(object.__init__), {...payload, executable: object.__init__})
+    }else {
+      if (url_callback) post_request({options:url_callback, data: object})
+    }
+  }
+
+  execute_function = (config, payload)=>{
+    let {arguments: args, location, url_callback, executable, metadata}=payload;
+    let {argv, argc} = args ||{};
+    argv = argv || []
+    let {parameters, object, __address__, method_address} = config;
+
+    let exec_address = method_address || __address__
+
+    this.stack.initiate(exec_address)
+
+    let arg_object = {}
+    parameters.map((p, i)=>{
+      arg_object[p.name] = {address: p.address, name: p.name, position: p.position || i}
+    })
+
+    for (let a =0; a< (argc || argv.length); a++){
+      let arg = argv[a]
+      let param;
+      if (arg.name) {
+        param = parameters.find(p=>p.name === arg.name)
+      } else {
+        param = parameters[arg.position]
+        arg.name = param.name
+      }
+
+      arg_object[arg.name].address = arg.address
+    }
+
+    if(object){
+      arg_object.this = {
+        position:-1, 
+        address: object,
+        name:'this'
+      }
+    }
+
+    for (let a in arg_object) {
+      let arg = arg_object[a]
+      let param_addr = `${exec_address}/${a}`
+      let param_chain = this.handle_chain(param_addr);
+
+      let arg_chain = this.handle_chain(arg.address)
+
+      if(arg_chain.datapath){
+        param_chain.set_obj_config(arg_chain.datapath)
+      }else {
+        let val = this.read_chain(arg_chain)
+        param_chain.forge_block({metadata: {output: this.account.save(val)}})
+      }
+    }
+
+    this.account.run({payload: {physical_address: method_address || __address__}, callback: ({ret})=>{
+      this.stack.pop(exec_address)
+      this.pop_context()
+
+      let res;
+      
+      if (typeof location === 'function'){
+        res = this.read_chain(ret)
+        if(metadata && metadata.loop){
+          
+          if (!metadata.loop.conditioner(res, metadata) && (metadata.loop.index+1) < metadata.loop.array.length){
+            metadata.loop.index ++
+
+            this.exec({executable, location, metadata, arguments: {argv: [{
+              address: metadata.loop.array[metadata.loop.index],
+              position: 0
+            }], argc: 1}})
+
+            return metadata.callback && metadata.callback(res)
+          }
+        }
+        location(res, metadata)
+        
+      }else if(ret){
+        let chain = this.handle_chain(ret)
+        let loc_chain = this.handle_chain(location)
+
+        if(chain.datapath){
+          res = chain.datapath;
+          loc_chain.set_obj_config(res)
+        }else {
+          res = this.read_chain(chain)
+          if (url_callback) post_request({options:url_callback, data: res})
+
+          loc_chain.forge_block({metadata: {output: this.account.save(res)}})
+          loc_chain.set_obj_config('')
+        }
+      }
+
+      if(metadata && metadata.callback){
+        metadata.callback(res)
+      }
+    }})
+  }
+
+  handle_method_config = ({name, method_addr, location, object})=>{
+    let conf = this.get_config(method_addr);
+    
+    let obj_method_addr = `${location}/${name}`
+    let chain = this.handle_chain(obj_method_addr)
+
+    conf.method_address = conf.__address__
+    conf.__address__ = obj_method_addr
+    conf.object = location;
+    chain.set_obj_config(conf)
+
+    object[name] = obj_method_addr;
+  }
+
+  get_config = exe =>{
+    let chn = this.handle_chain(exe);
+
+    if (!chn || (chn&& !chn.datapath))return this.stderr(`Executable:${exe} is not callable`)
+
+    return this.account.read(chn.datapath)
+  }
+}
+
+export default Executables

package/Executables/functions/adminstrator/adm_register.js

@@ -0,0 +1,29 @@
+import { render } from "./render";
+import native_components, { natives } from "./native_components";
+
+const adm_register = (account)=>{
+  let add_callable = account.vm.add_callable;
+
+  add_callable('render', {
+    callable:render,
+    config: {
+      parameters:[
+        {name:'object', position:0}
+      ]
+    }
+  })
+  
+  natives.map(name=>{
+    add_callable(name, {
+      callable:(args, vm, options)=>native_components(args, vm, {...options, name}),
+      config: {
+        parameters:[
+          {name:'props', position:0}
+        ]
+      }
+    })
+  })
+
+}
+
+export default adm_register;

package/Executables/functions/adminstrator/native_components.js

@@ -0,0 +1,10 @@
+let natives = ['Div', 'Text']
+
+const native_components = (args, vm, options)=>{
+  let {props} = args;
+
+  vm.write_chain(props, options.location)
+}
+
+export default native_components
+export {natives}

package/Executables/functions/adminstrator/query_selectors.js

@@ -0,0 +1,10 @@
+const get_element = (args, vm, options)=>{
+
+}
+
+const set_element = (args, vm, options)=>{
+  
+}
+
+
+export {get_element, set_element}

package/Executables/functions/adminstrator/render.js

@@ -0,0 +1,24 @@
+const render = (args, vm, options) => {
+  let {object, page} = args;
+
+  if (!object.render){
+    return vm.stderr({name:'Name_error', message:"A render method is neccessary for Adm display"})
+  }
+
+  let config = vm.read_chain(object.config)
+  config = vm.display(config);
+
+  console.log(config)
+  
+  vm.exec({executable: object.render, location: result=>{
+    let raw = vm.display(result, {include_address:true})
+
+    raw.address = object.__address__
+    raw.page = page;
+    
+    vm.air_object(raw, options)
+  }})
+  
+}
+
+export {render}

package/Executables/functions/array_register.js

@@ -0,0 +1,161 @@
+import {  concat, repeat, slice, pop, index, clear, insert,  replace, map, find, copy, filter } from "./methods/array";
+
+const array_register = (account)=>{
+  let add_callable = account.vm.add_callable;
+
+  add_callable('insert_', {
+    callable: insert,
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'value', position:1},
+        {name:'index', position:2},
+      ]
+    }
+  })
+
+  add_callable('arr_slice_', {
+    callable: slice,
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'start', position:1},
+        {name:'end', position:2},
+      ]
+    }
+  })
+
+  add_callable('arr_concat_', {
+    callable: concat,
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'other', position:1},
+        {name:'index', position:2},
+      ]
+    }
+  })
+
+  add_callable('extend_',{
+    callable: (args, vm, options) => concat(args, vm, {...options, spread:true}),
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'other', position:1},
+        {name:'index', position:2},
+      ]
+    }
+  })
+
+  add_callable('index_', {
+    callable: index,
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'n', position:1},
+      ]
+    }
+  })
+
+  add_callable('pop_', {
+    callable: pop,
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'index', position:1},
+      ]
+    }
+  })
+
+  add_callable('replace_', {
+    callable: replace,
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'index', position:1},
+        {name:'value', position:1},
+      ]
+    }
+  })
+
+
+  add_callable('repeat_', {
+    callable: repeat,
+    config: {
+      parameters: [
+        {name: 'arr', position:0},
+        {name: 'n', position:1},
+      ]
+    }
+  })
+
+  add_callable('clear_', {
+    callable: clear,
+    config: {
+      parameters: [
+        {name: 'arr', position:0},
+      ]
+    }
+  })
+
+  add_callable('findindex_', {
+    callable:(args, vm, options)=> find(args, vm, {...options, index: true}),
+    config: {
+      parameters: [
+        {name: 'arr', position:0},
+        {name: 'executable', position:1},
+      ]
+    }
+  })
+
+  add_callable('map_', {
+    callable: map,
+    config: {
+      parameters: [
+        {name: 'arr', position:0},
+        {name: 'executable', position:1},
+      ]
+    }
+  })
+
+  add_callable('find_', {
+    callable: find,
+    config: {
+      parameters: [
+        {name: 'arr', position:0},
+        {name: 'executable', position:1},
+      ]
+    }
+  })
+
+  add_callable('filter_', {
+    callable: filter,
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'executable', position:1},
+      ]
+    }
+  })
+
+  add_callable('copy_', {
+    callable: copy,
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+      ]
+    }
+  })
+
+  add_callable('deepcopy_', {
+    callable: (args, vm, options)=>copy(args, vm, {...options, deep:true}),
+    config: {
+      parameters: [
+        {name:'arr', position:0},
+        {name:'depth', position:1},
+      ]
+    }
+  })
+}
+
+export default array_register

package/Executables/functions/assign.js

@@ -0,0 +1,19 @@
+const assign = (args, vm, options)=>{
+  let {location, arguments: argg} = options;
+  let {value} = args;
+
+  let value_addr = argg.argv[0].address;
+  let value_chain = vm.handle_chain(value_addr);
+
+  let loc_chain = vm.handle_chain(location)
+  if(value_chain.datapath){
+    loc_chain.set_obj_config(value_chain.datapath)
+  }else {
+    
+    loc_chain.forge_block({metadata:{output: vm.account.save(value)}})
+    loc_chain.set_obj_config('')
+  }
+}
+
+
+export default assign

package/Executables/functions/display.js

@@ -0,0 +1,55 @@
+const display = (args, vm, options) => {
+  let { data } = args;
+
+  // console.log(args, 'display.args')
+  if (!Array.isArray(data)) data = [data];
+
+
+  if (options.metadata && options.metadata.raw){
+    return vm.display(vm.static_value(data[0]))
+  }
+
+  let val = new Array(data.length),
+    d = 0;
+
+  for (d = 0; d < data.length; d++) {
+    let dat = data[d];
+
+    if(!dat){continue}
+    if (dat.static_value) {
+      val[d] = dat.static_value;
+    } else if (dat.__print__) {
+      vm.exec({
+        executable: dat.__print__,
+        metadata: { index: d },
+        location: (result, metadata) => {
+          if (result.__print__) {
+            result = vm.static_value(result, true);
+            if (!result) {
+              this.stderr({
+                name: "Type_error",
+                message: `class.__print__ must return one of type boolean | string | number | twain | array | void`,
+              });
+            }
+          }
+          val[metadata.index] = result;
+
+          if (val.filter((v) => !!v).length === data.length) {
+            vm.display(val)
+          }
+        },
+      });
+    } else {
+      val[d] = JSON.stringify(dat);
+    }
+  }
+
+  if (val.filter((v) => !!v).length === data.length) {
+    vm.display(val)
+  }
+
+  if (options.metadata && options.metadata.raw)
+    return JSON.parse(val[0])
+};
+
+export { display };