godprotocol 1.1.1 → 1.1.2

package/Executables/executables.js

@@ -1,270 +0,0 @@
-import { generate_random_string } from "generalised-datastore/utils/functions";
-import Callables from "./callables";
-import Stack from "./stack";
-import Instance from '../Datatypes/instance'
-import { post_request } from "godprotocol/utils/services";
-
-
-class Executables extends Callables{
-  constructor(){
-    super()
-
-    this.stack = new Stack(this)
-  }
-  
-  handle_url_callback = (url_callback, payload)=>{
-    if (!url_callback)return;
-    
-    if(!payload){
-      payload = url_callback
-      url_callback = {socket: this.account.name}
-    }
-    if (url_callback.hostname) {
-      post_request({options:url_callback, data: payload})
-    }else if(url_callback.socket) {
-      this.account.manager.rt.send(url_callback, payload)
-    }
-  }
-
-  exec = (request, options)=>{
-    let payload = request.op0 || request;
-
-    let {executable, url_callback, location} = payload;
-
-    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(executable !== 'render' )
-      this.handle_url_callback(url_callback, 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, options)
-        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 {location, metadata} = payload
-    let {callback} = metadata || {}
-    
-    let object = new Instance({real_address: this.resolve_addr(`${location}/${generate_random_string(12, 'alnum')}`), classifier: this.resolve_addr(config.__address__)}, this)
-
-    for (let b=0; b < config.base_classes.length; b++){
-      let base = config.base_classes[b]
-    }
-
-    for (let name in config.methods){
-      this.handle_method_config({name, method_addr: config.methods[name], object})
-    }
-
-    object.store()
-    this.write_chain(object.stringify(), location)
-  
-    if(config.methods.__init__){
-      this.exec({...payload, executable: object.get_prop('__init__'), metadata: {callback}})
-    }else {
-      callback && callback(object)
-    }
-  }
-
-  execute_function = (config, payload, options)=>{
-    let {arguments: args, metadata, url_callback, location}=payload;
-    metadata = metadata || {}
-    options = options || {}
-
-    if (Array.isArray(args)) args = {argv: args, argc: args.length}
-
-    let {argv, argc} = args ||{};
-    argv = argv || []
-    let {parameters, object, method_address, __address__} = config;
-
-    if (!__address__.includes('/')){
-      return this.callable({...payload, config, executable: __address__})
-    }
-
-    let exec_address = method_address || __address__, pid;
-
-    pid = this.account.generate_pid()
-    this.track_pid = pid
-    this.stack.initiate(pid)
-
-    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 && param.name
-      }
-      if (!param) continue
-
-      if(!arg.address){
-        if (arg.hasOwnProperty('static_value')){
-          let args_buff = `${exec_address}/static_args`
-          let cont = this.air_object(arg.static_value, {location:args_buff, cascade:true})
-          arg_object[arg.name].address = `${args_buff}/${cont._id}`
-        }
-      }else 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.track_pid = null
-
-    this.account.run({payload: {physical_address: __address__, direct: pid, options}, callback: ({ret, pid})=>{
-      // console.log(pid, this.track.pid, "RETURN PID")
-      if (metadata.loop){
-        let {array, index, conditioner} = metadata.loop
-        let chck_condition = conditioner(this.read_chain(ret), metadata.loop)
-        if (chck_condition && (index+1) < array.length){
-          metadata.loop.index ++
-          index++
-
-          let new_pay = {...payload}
-
-          if(metadata.loop.exec){
-            new_pay.executable = array[index]
-          }else new_pay.arguments = {argv:[{address:array[index], position:0}, {static_value: index, position:1}]}
-
-          this.exec(new_pay)
-         
-          return
-        }
-      }
-
-      if (url_callback){
-        this.handle_url_callback(url_callback, this.literal(this.read_chain(ret)))
-      }
-
-      let result;
-      if (location){
-        if(typeof location === 'function'){
-          location(this.read_chain(ret), payload)
-        }else if(ret){
-          let loc = this.handle_chain(location)
-          let chain = this.handle_chain(ret)
-          
-          if(chain.datapath){
-            result = this.account.read(chain.datapath)
-            loc.set_obj_config(chain.datapath)
-          }else {
-            result = this.read_chain(chain)
-            this.write_chain(result, loc.physical_address, {prev_track: true})
-          }
-        }
-      }
-
-      metadata.callback && metadata.callback(result)
-    }})
-  }
-
-  handle_method_config = ({name, method_addr, object})=>{
-    let conf = this.get_config(method_addr);
-    
-    let instance_conf_addr = this.resolve_addr(`${object.object.real_address}/${name}`)
-    let chn = this.handle_chain(instance_conf_addr)
-
-    conf.method_address = this.unresolve_addr(conf.__address__)
-    conf.__address__ = instance_conf_addr
-    conf.real_address = instance_conf_addr
-    conf.object = object.object.real_address
-
-    chn.set_obj_config(conf)
-
-    object.add_prop(name, instance_conf_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, {callable:true})
-  }
-
-  handle_cache = (payload)=>{
-    let {executable, metadata, url_callback, arguments: args, location} = payload;
-
-    if (!metadata || (metadata && !metadata.cache))return;
-
-    if (executable.includes('/')){}
-    else {
-      if (executable === 'render')
-        location = `${location}/config`
-      
-      let data = this.read_chain(location)
-      console.log(data, 'statisc')
-      if (data){
-        console.log(data, 'HMMm')
-        this.handle_url_callback(url_callback, this.literal(data))
-        return true;
-      }
-      
-    }
-  }
-}
-
-export default Executables

package/Executables/functions/adminstrator/adm_register.js

@@ -1,41 +0,0 @@
-import { render } from "./render";
-import { navigate } from "./navigate";
-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},
-        {name:'window', position:1},
-      ]
-    }
-  })
-
-  add_callable('navigate', {
-    callable:navigate,
-    config: {
-      parameters:[
-        {name:'screen', position:0},
-        {name:'props', position:1},
-      ]
-    }
-  })
-  
-  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

@@ -1,10 +0,0 @@
-let natives = ['Div', 'Text', 'Button', 'Navigation', 'Screen', "Text_btn", 'Input', 'Scroll']
-
-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/navigate.js

@@ -1,7 +0,0 @@
-const navigate = (args, vm, options)=>{
-  let {screen, props} = args;
-
-  vm.handle_url_callback({socket: vm.account.name, client_route: 'navigate'}, {screen: vm.literal(screen), props: props && vm.literal(props)})
-}
-
-export {navigate}

package/Executables/functions/adminstrator/query_selectors.js

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

package/Executables/functions/adminstrator/render.js

@@ -1,31 +0,0 @@
-const pure_render = (res, vm, options)=>{
-  console.log(JSON.stringify(res, null, 2), 'SAVVYYY')
-  vm.exec({executable: res.namespace.render, location: (response)=>{
-    let raw = vm.literal(response)
-    console.log(JSON.stringify(raw, null, 2), 'ARRRGHHH')
-    vm.handle_url_callback(options.url_callback, raw)
-    vm.air_object(raw, {location: `${options.location}/config`, cascade: true})
-  }})
-}
-
-const render = (args, vm, options) => {
-  let {object, props} = args;
-
-  if (options.metadata && options.metadata.just_render){
-    return pure_render(object, vm, options)
-  }
-
-  if(!object.methods.render){
-    return vm.stderr({name: "Name_error", message: "object must contain a render method"})
-  }
-
-  vm.exec({executable: object.__address__, 
-    location: options.location,
-    metadata: {callback: (res)=>{
-
-      pure_render(res, vm, options)
-    }}, 
-    arguments:[{static_value: {props: props|| {}}, position: 0}]})  
-}
-
-export {render}

package/Executables/functions/array_register.js

@@ -1,159 +0,0 @@
-import {  extend, repeat, slice, pop, index, clear, insert,  splice, map, find, copy, filter, join } from "./methods/array";
-
-const array_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('insert', {
-    callable: insert,
-    config: {
-      parameters: [
-        {name:'value', position:0},
-        {name:'index', position:1},
-      ]
-    }
-  })
-
-  add_callable('push', {
-    callable: insert,
-    config: {
-      parameters: [
-        {name:'value', position:0}
-      ]
-    }
-  })
-
-  add_callable('join', {
-    callable: join,
-    config: {
-      parameters: [
-        {name:'delimeter', position:0}
-      ]
-    }
-  })
-
-  add_callable('arr_slice', {
-    callable: slice,
-    config: {
-      parameters: [
-        {name:'start', position:0},
-        {name:'end', position:1},
-      ]
-    }
-  })
-
-  add_callable('extend', {
-    callable: extend,
-    config: {
-      parameters: [
-        {name:'other', position:0},
-        {name:'index', position:1},
-      ]
-    }
-  })
-
-  add_callable('index', {
-    callable: index,
-    config: {
-      parameters: [
-        {name:'n', position:0},
-      ]
-    }
-  })
-
-  add_callable('pop', {
-    callable: pop,
-    config: {
-      parameters: [
-        {name:'index', position:0},
-      ]
-    }
-  })
-
-  add_callable('splice', {
-    callable: splice,
-    config: {
-      parameters: [
-        {name:'index', position:0},
-        {name:'count', position:1},
-        {name:'replacement', position:2},
-      ]
-    }
-  })
-
-
-  add_callable('repeat', {
-    callable: repeat,
-    config: {
-      parameters: [
-        {name: 'n', position:0},
-      ]
-    }
-  })
-
-  add_callable('clear', {
-    callable: clear,
-    config: {
-      parameters: [
-      ]
-    }
-  })
-
-  add_callable('findindex', {
-    callable:(args, vm, options)=> find(args, vm, {...options, index: true}),
-    config: {
-      parameters: [
-        {name: 'executable', position:0},
-      ]
-    }
-  })
-
-  add_callable('map', {
-    callable: map,
-    config: {
-      parameters: [
-        {name: 'executable', position:0},
-        {name: 'spawn', position:1},
-      ]
-    }
-  })
-
-  add_callable('find', {
-    callable: find,
-    config: {
-      parameters: [
-        {name: 'executable', position:0},
-      ]
-    }
-  })
-
-  add_callable('filter', {
-    callable: filter,
-    config: {
-      parameters: [
-        {name:'executable', position:0},
-        {name:'spwan', 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

@@ -1,10 +0,0 @@
-const assign = (args, vm, options)=>{
-  let {value} = args;
-
-  if (!value)return vm.stderr('Invalid.')
-
-  vm.write_chain(value, options.location)
-}
-
-
-export default assign

package/Executables/functions/condition.js

@@ -1,14 +0,0 @@
-const condition = (args, vm, options) => {
-  let {invert} = options;
-  let {predicate, pointer} = args;
-
-  if (typeof predicate !== 'boolean'){
-    predicate = vm.literal(predicate)
-  }
-
-  if (invert? !!predicate : !!!predicate){
-    vm.track.pointer += pointer
-  }
-}
-
-export default condition

package/Executables/functions/display.js

@@ -1,44 +0,0 @@
-const display = (args, vm, options) => {
-  let { data } = args;
- 
-  let arr, sticks = new Array();
-  for (let d = 0; d< data.length; d++){
-    let datum = data[d]
-
-    if (datum.type && !['funciton', ...vm.air_types].includes(datum.type)){ 
-      if (datum.type === 'instance'){
-        if (!datum.namespace.__print__){
-          sticks.push('[Instance]')
-        }else {
-          if (!arr) arr = new Array()
-
-          arr.push({datum, d})
-        }
-      }
-      
-    } else {
-      sticks.push(vm.literal(datum))
-    }
-  }
-  
-  if (!arr){
-    vm.run_opcode(sticks, 'stdout')
-  }else if (arr.length){
-    let metadata = {
-      loop:{
-        exec:true,
-        index: 0, array: arr.map(d=>d.datum.namespace.__print__),
-        conditioner: (res, loop)=>{
-          let d = arr[loop.index]
-          sticks.splice(d.d, 0, vm.literal(res))
-          return true;
-        }
-      }
-    }
-    vm.exec({executable: arr[0].datum.namespace.__print__, metadata, location:()=>{
-      vm.run_opcode(sticks, 'stdout')
-    }})
-  }
-};
-
-export { display };

package/Executables/functions/folder.js

@@ -1,95 +0,0 @@
-const readone = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.readone(res), options)
-  })
-}
-
-const read = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.read(res), options)
-  })
-}
-
-const clean_check_folder = (args, vm)=>{
-  let {folder}= args;
-
-  let name = vm.read_chain(folder.name)
-  if(name.__classifier__ !== vm.get_type_address('string')){
-    return vm.stderr({name:'Type_error', message: "Folder name must be a string."})
-  }else name = vm.static_value(name);
-
-  let fold = vm.account.manager.oracle.gds.folder(name.static_value)
-
-  return {name, fold}
-}
-
-const write = (args, vm, options) =>{
-  let {data} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-  
-  vm.display(data, (res)=>{
-    vm.air_object(fold.write(res), options)
-  })
-}
-
-const write_several = (args, vm, options) =>{
-  let {data} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(data, (res)=>{
-    vm.air_object(fold.write_several(res), options)
-  })
-}
-
-
-const remove = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.remove(res), options)
-  })
-}
-
-const remove_several = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.remove_several(res), options)
-  })
-}
-
-const update = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.update(res), options)
-  })
-}
-
-const update_several = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.update_several(res), options)
-  })
-}
-
-export {read, readone, update, update_several, write, write_several, remove, remove_several}