godprotocol 1.1.31 → 1.2.0

package/Objects/Callable.js

@@ -1,4 +1,4 @@
-import Vm_utils from "../utils/vm_utils";
+import Vm_utils from "../utils/vm_utils.js";
 
 class Callable extends Vm_utils {
   constructor() {
@@ -7,208 +7,208 @@ class Callable extends Vm_utils {
     this.objects = new Object();
   }
 
-  parse_aircode = async (result, { config, chain }) => {
+  parse_aircode = async (result, { config, chain, id }) => {
     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];
+    let loc = config && config.location.split("/").slice(2).join("/")
+    
+    result = result === 'void'? result: JSON.stringify(result)
+    if (result === 'void') return await this.voided()
 
+    let res = await this.account.compiler.to_sequence(
+      result,
+      !loc ? "CONSTANTS" : loc
+    )
+    res = res[0].body[0];
+    
     await chain.add_config(res);
-    result = await this.execute(res, { chain });
+    result = await this.execute(res, { chain, id });
 
     return result;
   };
 
-  resolve_address = async (path, chain) => {
-    let oracle = this.account.manager.oracle,
-      fs = oracle.fs;
+  instantiate = async (config, { chain, value, _id }) => {
+    let chn = await chain.chain(config.location)
+    let folder = await chn.folder()
 
-    if (typeof path !== "string") {
-      return path;
+    if (['void', 'boolean'].includes(config.type)){
+      let res = await this.statics(config)
+      return res;
     }
 
-    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;
+    let obj = {
+      _id,
+      type: config.type,
+      created: Date.now(),
+      location: folder.address
+    }, res;
+    
+    if(config.type === 'error'){
+      obj.value = config.payload
+      res = await folder.write(obj)
+      obj._id = res._id
+      
+    } else if (config.type === 'twain'){
+      res = await folder.write(obj)
+      obj._id = res._id
+      obj.created = res.created
+
+      if (value){
+        let val_obj = await this.cloth(value)
+        let obj_obj = await this.cloth_content(obj)
+        obj_obj.address = folder.address
+        await obj_obj.extend(val_obj)
+      }else {
+        for (let key in config.value){
+          let [prop, value] = config.value[key]
+          if(typeof prop === 'string'){
+            prop = await this.execute(await this.read_config(prop), {chain})
+          }
+          if(typeof value === 'string'){
+            value = await this.execute(await this.read_config(value), {chain})
+          }
+          await chn.set({twa: obj, key, prop, 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;
+      
+      res = await folder.write(obj, {replace: true})
+    }else if (config.type === 'array'){
+      obj.length = 0
+
+      res = await folder.write(obj)
+      obj._id = res._id
+      obj.created = res.created
+      
+      if (value){
+        let val_obj = await this.cloth(value)
+        let obj_obj = await this.cloth_content(obj)
+        obj_obj.address = folder.address
+        await obj_obj.extend(val_obj)
+      }else {
+        for (let i =0; i < config.value.length; i++){
+          let item = config.value[i]
+          if (typeof item === 'string'){
+            item = await this.execute(await this.read_config(item), {chain})
+          }
+          await chn.insert({arr: obj, item, index: obj.length})
         }
       }
-      config.value = JSON.stringify(config.value);
+      
+      res = await folder.write(obj, {replace: true})
+    }else if (['string', 'number', 'void', 'boolean'].includes(config.type)){
+      if (value){
+        folder = await this.account.manager.ds.folder(value.value)
+        obj._id = value._id
+      }else {
+        obj.value = config.value
+        res = await folder.write(obj)
+        obj._id = res._id
+        obj.created = res.created
+        obj.address = folder.address
+      } 
+    }
+    res = {
+      value: folder.address,
+      type: 'address',
+      _id: obj._id
     }
 
-    let res = await instance_chain.write(
-      { content: config.value, __classifier__: config.type, uid },
-      { hash, is_instance: true }
-    );
-    return res;
+    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;
-  };
+  callable_address = async (config, o)=>{
+    let obj = await this.cloth_content(config)
+    obj.address = config.address
 
-  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 o ? obj : await obj.to_address()
+  }
+  
+  execute_call = async (call_config, { chain, thread }) => {
+    let result;
+    let {identifier, arguments: args, location} = call_config
+    
+    if (location){
+      location = await chain.chain(location)
     }
 
-    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);
+    if (identifier.type === 'address'){
+      // If call is a reference, such as to a class method
+      let {object, value, config: is_config} = identifier
+      if (object){
+        let spl = this._split_datapath(object)
+        let obj = {value: spl[0], _id: spl[1], type: 'address', config: is_config}
+        obj = await this.cloth(obj)
+        
+        if (value.includes('/')){
+          await obj.run(call_config, {thread, chain})
+        }else{
+          result = await obj.call(value, {chain, call_config, thread})
         }
-        result = await this.execute(conf, { call_config, chain });
+      }else {
+        let obj = await this.cloth(identifier)
+        if (['class', 'function', 'instance'].includes(obj.type)){
+
+        }else result = await this.throw_error({type:"TypeError", message: `type ${obj.type} is not callable.`})
       }
-    } 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 (['function', 'class'].includes(identifier.type)){
+      let call = await this.cloth(identifier)
+      await call.invoke(args, {chain, call_config, thread})
+    } else if (identifier.includes('/')){
+      // If call is a user-defined address
+      let folder = await this.account.manager.ds.folder(identifier)
+      let payload = await folder.readone()
+
+      if (payload.object){
+        result = await this.execute_call({...call_config, identifier: payload}, {chain, thread})
+      }else {
+        if (payload.config && payload._id === payload.value){
+          result = await this.execute_call({...call_config, identifier: payload._id}, {chain, thread})
+        }else {
+          let call = await this.cloth(payload)
+          await call.invoke(args, {chain, call_config, thread})
         }
-      } 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)){
+      // If call is Datatype instantiation
+ 
+      let _id = call_config.arguments.find(p=>p.identifier === '_id')
+      if (_id){
+        delete _id.identifier
+        _id = await this.cloth({..._id})
+        if (_id.type === 'string')
+          _id = await this.hash(await _id.literal())
+        else _id = null
+      }else _id = null
+      let val = call_config.arguments.find(p=>p.identifier === 'value')
+      val = (val && val.value) || call_config.arguments[0]
+      result = await this.instantiate({type: identifier, location: call_config.location}, {chain, _id, value: val})
+    } else if (this.err_objects.includes(identifier)){
+      let message = await (await this.cloth(args[0])).literal()
+      result = await this.throw_error({message, type: identifier})
     } 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;
-            }
+      // If call is a reserved word.
+
+      let call = await this.callable(identifier)
+      let {callable, config} = call;
+      let data = {}
+      for (let a = 0; a < args.length; a++) {
+        let param;
+        let arg = args[a];
+        
+        if (arg.identifier) 
+          param = config.parameters.find(p=>p.name === arg.identifier)
+        
+        if(!param) {
+          param = config.parameters[arg.position || a];
+          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 });
+        }
+
+        let res = await this.cloth(arg);
+        
+        if (param){
           if (param.spread) {
             let arr = data[param.name];
             if (!arr) {
@@ -218,20 +218,47 @@ class Callable extends Vm_utils {
             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,
-          });
+      }
+      
+      result = await callable(data, {vm: this, call_config, chain, thread})
+      
+      if( ['store', 'net'].includes(identifier)){
+        result = await this.voided()
+      } else if(identifier === 'parse' && result){
+      }else if (['Twain', 'folder'].includes(identifier)){
+        result = await result.to_address()
+      } else if(result && ['address', 'function'].includes(result.type)){
+      } else { 
+        result = await this.parse_aircode(result, {
+          config: call_config,
+          chain,
+        });
       }
     }
 
     return result;
   };
 
+  resolve_import = async(config, chain)=>{
+    let addr = this.resolve_addr(config.address),
+      oracle = this.account.manager.oracle;
+
+    for (let i=0; i< config.identifiers.length; i++){
+      let id = config.identifiers[i]
+
+      let conf = await oracle.read(`${oracle.manager.path}/${addr}/${id}`, {config: true})
+
+      await this.execute({
+        type: 'assignment',
+        identifier: id,
+        value: {
+          type: 'address',
+          value: conf.path
+        }
+      }, {chain})
+    }
+  }
+
   callable = async (name) => {
     let object = this.objects[name];
 
@@ -242,24 +269,32 @@ class Callable extends Vm_utils {
     this.objects[name] = config;
   };
 
-  native_components = async (config, chain) => {
+  native_components = async (config, {chain, object}) => {
     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 res = await this.execute(child, { chain, cloth: true, object });
+      children.push(await res.literal({adm:true}));
     }
 
     let obj = {
       name: config.name,
-      props: await props.literal(),
+      props: await props.literal({adm:true}),
       children,
+      _id: props.config._id,
+      path: props.path
     };
 
-    return obj;
+    let result = await this.parse_aircode(obj, {config, chain})
+
+    return result;
   };
+
+  rerender = async(object)=>{
+
+  }
 }
 
 export default Callable;