godprotocol 1.1.2 → 1.1.3

package/Objects/Callable.js

@@ -1,30 +1,190 @@
-class Callable {
+import Vm_utils from "../utils/vm_utils";
+
+class Callable extends Vm_utils {
   constructor() {
+    super();
+
     this.objects = new Object();
   }
 
-  parse_arguments = async (payload, config) => {
-    let { args } = payload;
-    let aggs = new Object();
+  parse_aircode = async(result, {config, chain})=>{
+    if (result == null)result = 'void';
 
-    for (let a = 0; a < args.length; a++) {
-      let arg = args[a];
+    let res = await this.account.aircode.to_sequence(JSON.stringify(result), config.location.split('/').slice(2).join('/'))[0].body[0]
 
-      let content = await this.read_chain(arg),
-        param;
-      if (content.type === "variable") {
-        param = config.parameters.find((p) => p.name === content.identifier);
+    await chain.add_config(res)
+    result = await this.execute(res, {chain})
 
-        if (!param) return await this.stderr({ name: "unidentified_argument" });
+    return result
+  }
 
-        content = await this.read_chain(content.value);
-      } else param = config.parameters[a];
+  resolve_address = async (path, chain)=>{
+    let oracle = this.account.manager.oracle, 
+      fs = oracle.fs;
 
-      aggs[param.name] = content;
+    if (typeof path !== 'string'){
+      return path
     }
 
-    return aggs;
-  };
+    if(path == 'g')throw new Error()
+    let conf = await fs.read(`${path}/.config`), value;
+    if (!conf.current){
+      value = await fs.read(`${path}/${conf.index-1}`)
+      value = JSON.parse(value.content)
+    }else value = await fs.read(`${path}/${conf.current}`)
+    value.path = path
+    
+    return value;
+  }
+
+  instantiate = async(config, {chain, hash, pure})=>{
+    let instance_chain = await chain.chain(config.type === 'void'? config.value : config.location);
+    let uid = this.gen_uid()
+
+    if (config.type === 'twain'){
+      if (!pure){
+        for (let p in config.value){
+          let pair = config.value[p]
+  
+          pair[0] = (await this.execute(pair[0], {chain})).value
+          pair[1] = (await this.execute(pair[1], {chain})).value
+        }
+      }
+     
+      config.value = JSON.stringify(config.value)
+    }else if(config.type === 'array'){
+      if (!pure){
+        for (let i=0; i< config.value.length; i++){
+          let item = config.value[i]
+          config.value[i] = (await this.execute(item, {chain})).value
+        }
+      }
+      config.value = JSON.stringify(config.value)
+    }
+
+    let res = await instance_chain.write({content: config.value, __classifier__: config.type, uid}, {hash, is_instance: true})
+    return res;
+  }
+
+  operate_result = async (value, call_config, chain)=>{
+    let result;
+    if (value && value.error){
+      result = value
+    }else if(value && value.type === 'address'){
+      result = value
+    } else result = await this.parse_aircode(value, {config: call_config, chain})
+
+    return result
+  }
+
+  object_identifier = async (call_config, chain)=>{
+    let {identifier, }= call_config, result, oracle = this.account.manager.oracle;
+    let conf = await oracle.fs.read(`${identifier.object}/.config`)
+    let obj = await oracle.fs.read(`${identifier.object}/${conf.current}`);
+
+    let res = await this.cloth_content({...obj, path: identifier.object})
+    let classifier = await res.get('__classifier__')
+    
+    if (this.datatypes.includes(classifier)){
+      for (let a=0; a < call_config.arguments.length; a++)
+        call_config.arguments[a] = await this.execute(call_config.arguments[a], {chain, cloth: true})
+      
+      let value = await res.operate(identifier.value, call_config.arguments, {classifier, config: call_config, chain})
+      result = await this.operate_result(value, call_config, chain)
+    }else {
+      let conf = await oracle.fs.read(`${identifier.value}/.config`)
+      conf = await oracle.fs.read(`${identifier.value}/${conf.index-1}`)
+      let content = JSON.parse(conf.content)
+
+      let val = await this.execute(content, {chain, call_config: {...call_config, object: {type:'address', value: identifier.object}}})
+
+      result = val
+    }
+
+    return result
+  }
+
+  execute_call = async(call_config, {chain, obj})=>{
+    let {identifier, arguments: args} = call_config, result;
+
+    if(typeof identifier !== 'string'){
+      if (identifier.object){
+        result = await this.object_identifier(call_config, chain)
+      }else {
+        let conf = await this.read_config(identifier.value)
+        if(!['function', 'class'].includes(conf.type)){
+          conf = await obj.get(identifier.prev_name, {obj:identifier.prev_name})
+          conf = await this.resolve_address(conf.value)
+        }
+        result = await this.execute(conf, {call_config, chain})
+      }
+    } else if (identifier.includes('/')){
+      let oracle = this.account.manager.oracle;
+      let i_chain = identifier.startsWith(this.account.manager.path)? {path: identifier} : await chain.chain(identifier)
+      let conf = await oracle.fs.read(`${i_chain.path}/.config`)
+      
+      if(conf.sibling){
+        let config = await oracle.fs.read(conf.sibling)
+        
+        if (config.content.type === 'address'){
+          if (config.content.object){
+            result = await this.object_identifier({...call_config, identifier: config.content}, chain)
+          }else {
+            let iconf = await oracle.fs.read(`${config.content.value}/.config`);
+            let configg = await oracle.fs.read(`${config.content.value}/${iconf.index-1}`)
+            
+            result = await this.execute(JSON.parse(configg.content), {call_config, chain})
+          } 
+        }
+      }else if(conf.current) {
+        let iconf = await oracle.fs.read(`${conf.current}/.config`);
+        let config = await oracle.fs.read(`${conf.current}/${iconf.index-1}`)
+        
+        result = await this.execute(JSON.parse(config.content), {call_config, chain})
+      }else {
+        let config = await oracle.fs.read(`${call_config.identifier}/${conf.index-1}`)
+        result = await this.execute(JSON.parse(config.content), {call_config, chain})
+      }
+     }
+    else {
+      if (this.datatypes.includes(identifier)){}
+      else {
+        let {callable, config} = await this.callable(identifier)
+        let data = {}
+        
+        for (let a=0; a< args.length; a++){
+          let param;
+          let arg = args[a]
+          if(arg.identifier){
+
+          }else {
+            param = config.parameters[arg.position]
+            if (!param){
+              let lst_param = config.parameters.slice(-1)[0]
+              if (lst_param.spread) param = lst_param;
+            }
+          }
+          let res = await this.execute(arg, {chain, cloth: true})
+          if (param.spread){
+            let arr = data[param.name]
+            if (!arr){
+              arr = new Array();
+              data[param.name] = arr;
+            }
+            arr.push(res)
+          }else data[param.name] = res;
+        }
+        
+        result = await callable(data)
+        if (identifier === 'exit' || identifier === 'Twain'){
+          
+        }else result = await this.parse_aircode(result, {config: call_config, chain})
+      }
+    }
+
+    return result 
+  }
+  
 
   callable = async (name) => {
     let object = this.objects[name];

package/Objects/Chain.js

@@ -1,39 +1,200 @@
-import Block from "./Block";
-
-class Chain {
-  constructor(address, account) {
-    this.physical_address = address;
-    this.account = account;
-    this.blocks = new Array();
-    this.servers = new Array();
+import Storage from "godprotocol/Datatypes/functions/storage";
+
+class Folder extends Storage{
+  constructor(address, parent) {
+    super(parent && parent.account.manager)
+
+    this.account = parent.account;
+    this.physical_address = address
+    this.path = `${this.account.manager.path}/${this.physical_address}`
+    this.parent = parent;
+  }
+
+  sync = async()=>{}
+
+  birth = async physical_address =>{
+    let folder = new Folder(physical_address, this);
+    await folder.sync()
+
+    return folder
+  }
+
+  chain = async(address)=>{
+    if (!address.includes('/'))address = `${this.physical_address}/${address}`
+    
+    let chain = await this.account.manager.web.set(address, this)
+    return chain;
   }
 
-  sync = async () => {
-    this.folder = await this.account.manager.oracle.folder(
-      this.physical_address
-    );
-  };
+  write = async (content, options)=>{
+    let res;
+    if (content && content.type === 'address' && options.hash) {
+      let oracle = this.account.manager.oracle;
+      let conf = await oracle.fs.read(`${this.path}/.config`) || {}
+      
+      let pth = `${this.path}/${options.hash}`
+      let p_conf = await oracle.fs.read(`${pth}/.config`) || {}
+      let obj = {content, type: 'reference', previous: p_conf.current, sibling: conf.sibling}
+      let hsh = await oracle.hash(obj)
+      res = `${pth}/${hsh}`;
 
-  write = async (payload) => {
-    let address = await this.account.manager.oracle.write(payload);
+      await oracle.fs.write(res, JSON.stringify(obj))
+      p_conf.current = res
+      await oracle.fs.write(`${pth}/.config`, JSON.stringify(p_conf))
+      
+      conf.sibling = res;
+      await oracle.fs.write(`${this.path}/.config`, JSON.stringify(conf))
+    }else {
+      res = await this.persist(content, {...options })
+    }
+    return res
+  }
 
-    let block = new Block({ content: address }, this);
-    await block.sync();
+  read =async (options={})=>{
+    let res = await this.retrieve(options)
+    
+    return res;
+  }
 
-    this.blocks.push(block);
-  };
+  write_config = async (config, options={})=>{
+    return await this.persist(config, {...options, config: true, })
+  }
+  
+  add_config = async (config, options={})=>{
+    let result;
 
-  read = async (query) => {
-    let { index } = query;
+    switch(config.type){
+      case 'module':
+        for (let b=0; b < config.body.length; b++){
+          let line = config.body[b]
 
-    if (index != null) return await this.get_block(index);
+          config.body[b] = await this.add_config(line)
+        }
+        result = await this.write_config(config)
+        break;
+      case 'class':
+        let class_chain = await this.chain(config.name)
+        for (let name in config.methods){
+          config.methods[name] = await class_chain.add_config(config.methods[name])
+        }
 
-    return await this.get_block();
-  };
+        result = await class_chain.write_config(config)
+        break;
+      case 'function':
+        let fn_chain = await this.chain(config.name)
+        for (let p=0; p< config.parameters.length; p++){
+          config.parameters[p] = await fn_chain.add_config(config.parameters[p])
+        }
+        for (let b=0; b< config.body.length; b++){
+          
+          config.body[b] = await fn_chain.add_config(config.body[b])
+        }
+        result = await fn_chain.write_config(config)
+        break;
+      case 'return':
+        config.output = await this.add_config(config.output)
+        result = config
+        break;
+      case 'raise':
+        config.object = await this.add_config(config.object)
+        result = config
+        break;
+      case 'trycatch':
+        let try_chain = await this.chain(config.location);
+        for (let t=0;t< config.try_body.length; t++){
+          config.try_body[t] = await this.add_config(config.try_body[t])
+        }
+        for (let t=0;t< config.catch_body.length; t++){
+          config.catch_body[t] = await this.add_config(config.catch_body[t])
+        }
+        if (config.alias){
+          config.alias = await this.add_config({type:'assignment', identifier: config.alias.value, value: {type:'void', value:'void'}})
+        }
+        result = await try_chain.write_config(config)
+        break;
+      case 'condition':
+        let cond_chain = await this.chain(config.location)
+        for(let b= 0; b< config.blocks.length; b++){
+          let block= config.blocks[b]
+          block.predicate = await cond_chain.add_config(block.predicate)
+          for (let i=0; i< block.body.length; i++){
+            block.body[i] = await cond_chain.add_config(block.body[i])
+          }
+        }
+        result = await cond_chain.write_config(config)
+        break;
+      case 'assignment':
+        let ass_chain = await this.chain(config.identifier)
+        
+        config.value = await ass_chain.add_config(config.value);
+
+        result = await ass_chain.write_config(config)
+        break;
+      case 'loop':
+        let loop_chain = await this.chain(config.location)
+        config.condition = await this.add_config(config.condition)
+        if(config.loop_type === 'for'){
+          config.iterator = await this.add_config(config.iterator)
+          config.update = await this.add_config(config.update)
+        }
+        
+        for (let b=0; b< config.body.length; b++){
+          config.body[b] = await this.add_config(config.body[b])
+        }
+        result = await loop_chain.write_config(config)
+        break;
+      case 'call':
+        if(config.identifier.type === 'nest'){
+          let addr = await this.add_config(config.identifier)
+          config.identifier = {address: addr, type: 'nest'}
+        }
+        let call_chain = await this.chain(config.location)
+        for(let a=0; a< config.arguments.length; a++){
+          config.arguments[a] = await call_chain.add_config(config.arguments[a])
+        }
+        result = await call_chain.write_config(config)
+        break;
+      case 'nest':
+        let nest_chain = await this.chain(config.location)
+        for (let n=0; n< config.nests.length; n++){
+          config.nests[n] = await nest_chain.add_config(config.nests[n])
+        }
+        if(config.assignment)
+          config.assignment = await nest_chain.add_config(config.assignment)
+        
+        result = await nest_chain.write_config(config)
+        break;
+      default: 
+        if (['number', 'string', 'boolean'].includes(config.type)){
+          result = await (await this.chain(config.location)).write_config(config)
+        }else if(['variable', 'address', 'reference'].includes(config.type)){
+          result = config;
+        }else if (config.type === 'void'){
+          result = config
+        }else if(config.type === 'twain'){
+          let c_chain = await this.chain(config.location)
+          for (let p in config.value){
+            let pair = config.value[p]
+            pair[0] = await this.add_config(pair[0])
+            pair[1] = await this.add_config(pair[1])
+          }
+          result = await c_chain.write_config(config)
+        } else if(config.type === 'array'){
+          let c_chain = await this.chain(config.location)
+          for (let i=0; i< config.value.length; i++){
+            let item = config.value[i]
+            config.value[i] = await this.add_config(item)
+          }
+          result = await c_chain.write_config(config)
+        }else if (['break', 'continue'].includes(config.type)){
+          result = config;
+        }
+      
+    }
+
+    return result;
+  }
 
-  get_block = async (index) => {
-    return this.blocks[index == null ? this.blocks.length - 1 : index];
-  };
 }
 
-export default Chain;
+export default Folder;