godprotocol 1.1.2 → 1.1.31

package/Objects/Callable.js

@@ -1,29 +1,235 @@
-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";
+
+    let res = await this.account.compiler.to_sequence(
+      JSON.stringify(result),
+      config.location.split("/").slice(2).join("/")
+    )[0].body[0];
+
+    await chain.add_config(res);
+    result = await this.execute(res, { chain });
+
+    return result;
+  };
+
+  resolve_address = async (path, chain) => {
+    let oracle = this.account.manager.oracle,
+      fs = oracle.fs;
+
+    if (typeof path !== "string") {
+      return path;
+    }
+
+    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 });
 
-    for (let a = 0; a < args.length; a++) {
-      let arg = args[a];
+    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;
+  };
 
-      let content = await this.read_chain(arg),
-        param;
-      if (content.type === "variable") {
-        param = config.parameters.find((p) => p.name === content.identifier);
+  execute_call = async (call_config, { chain, obj }) => {
+    let { identifier, arguments: args } = call_config,
+      result;
 
-        if (!param) return await this.stderr({ name: "unidentified_argument" });
+    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`);
 
-        content = await this.read_chain(content.value);
-      } else param = config.parameters[a];
+      if (conf.sibling) {
+        let config = await oracle.fs.read(conf.sibling);
 
-      aggs[param.name] = content;
+        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, { vm: this, config, chain });
+        if (["Twain", "exit", "render"].includes(identifier)) {
+        } else
+          result = await this.parse_aircode(result, {
+            config: call_config,
+            chain,
+          });
+      }
     }
 
-    return aggs;
+    return result;
   };
 
   callable = async (name) => {
@@ -35,6 +241,25 @@ class Callable {
   set = (name, config) => {
     this.objects[name] = config;
   };
+
+  native_components = async (config, chain) => {
+    let props = await this.execute(config.props, { chain, cloth: true });
+    let children = new Array();
+    for (let c = 0; c < config.children.length; c++) {
+      let child = config.children[c];
+
+      let res = await this.execute(child, { chain, cloth: true });
+      children.push(await res.literal());
+    }
+
+    let obj = {
+      name: config.name,
+      props: await props.literal(),
+      children,
+    };
+
+    return obj;
+  };
 }
 
 export default Callable;

package/Objects/Chain.js

@@ -1,39 +1,208 @@
-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;
+  }
+
+  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};
+
+      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
+  }
+
+  read =async (options={})=>{
+    let res = await this.retrieve(options)
+
+    return res;
+  }
+
+  write_config = async (config, options={})=>{
+    return await this.persist(config, {...options, config: true, })
   }
 
-  sync = async () => {
-    this.folder = await this.account.manager.oracle.folder(
-      this.physical_address
-    );
-  };
+  add_config = async (config, options={})=>{
+    let result;
+
+    switch(config.type){
+      case 'module':
+        for (let b=0; b < config.body.length; b++){
+          let line = config.body[b]
+
+          config.body[b] = await this.add_config(line)
+        }
+        result = await this.write_config(config)
+        break;
+      case 'adm':
+        let adm_chain = await this.chain(config.location)
+        config.props = await this.add_config(config.props)
+        for (let c=0; c< config.children.length; c++){
+          config.children[c] = await this.add_config(config.children[c])
+        }
+        result = await adm_chain.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])
+        }
 
-  write = async (payload) => {
-    let address = await this.account.manager.oracle.write(payload);
+        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++){
 
-    let block = new Block({ content: address }, this);
-    await block.sync();
+          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)
 
-    this.blocks.push(block);
-  };
+        config.value = await ass_chain.add_config(config.value);
 
-  read = async (query) => {
-    let { index } = query;
+        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)
+        }
 
-    if (index != null) return await this.get_block(index);
+        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)
 
-    return await this.get_block();
-  };
+        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;