godprotocol 1.1.32 → 1.2.0

package/Objects/Chain.js

@@ -1,208 +1,193 @@
-import Storage from "godprotocol/Datatypes/functions/storage";
+import Datatypes from "./Datatypes.js";
 
-class Folder extends Storage{
-  constructor(address, parent) {
-    super(parent && parent.account.manager)
+class Chain extends Datatypes{
+  constructor(address, account){
+    super()
 
-    this.account = parent.account;
-    this.physical_address = address
-    this.path = ${this.account.manager.path}/${this.physical_address}
-    this.parent = parent;
+    this.address = address
+    this.account = account;
   }
 
-  sync = async()=>{}
+  chain = async(address)=>{
+    let chain = new Chain(address, this.account)
+    return chain;
+  }
 
-  birth = async physical_address =>{
-    let folder = new Folder(physical_address, this);
-    await folder.sync()
+  folder = async (path)=>{
+    let fold = await this.account.ds.folder(this.address)
+    let folder = path ? await fold.folder(path) : fold
 
     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;
+  read = async()=>{
+    let folder = await this.folder()
+    return await folder.readone()
   }
 
-  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
+  write = async(data)=>{
+    let folder = await this.folder()
+    return await folder.write(data)
   }
 
-  read =async (options={})=>{
-    let res = await this.retrieve(options)
-
-    return res;
-  }
+  write_config = async(config, options={})=>{
+    let folder = await this.folder('.configs')
 
-  write_config = async (config, options={})=>{
-    return await this.persist(config, {...options, config: true, })
+    let res = await folder.write(
+      {...config, _id: options._id || config._id}, 
+      {replace: !!config._id || options.replace}
+    )
+    return res.datapath
   }
 
-  add_config = async (config, options={})=>{
+  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])
-        }
-
-        result = await class_chain.write_config(config)
+        result = await this.write_config(config, options)
         break;
       case 'function':
-        let fn_chain = await this.chain(config.name)
-        for (let p=0; p< config.parameters.length; p++){
+        let fn_chain = await this.chain(config.address)
+        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++){
-
+        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])
+      case 'class':
+        let cls_chain = await this.chain(config.address);
+        for (let name in config.methods){
+          let met = config.methods[name]
+          let res = await cls_chain.add_config(config.methods[name])
+          
+          config.methods[name] = `${met.address}/${met._id}`
         }
-        for (let t=0;t< config.catch_body.length; t++){
-          config.catch_body[t] = await this.add_config(config.catch_body[t])
+        for (let name in config.properties){
+          let met = config.properties[name]
+          let res = await cls_chain.add_config(config.properties[name])
+          config.properties[name] = res
         }
-        if (config.alias){
-          config.alias = await this.add_config({type:'assignment', identifier: config.alias.value, value: {type:'void', value:'void'}})
+
+        for (let name in config.class_.properties){
+          let met = config.class_.properties[name]
+          let res = await cls_chain.add_config(config.class_.properties[name])
+          config.class_.properties[name] = res
         }
-        result = await try_chain.write_config(config)
-        break;
+
+        for (let name in config.class_.methods){
+          let met = config.class_.methods[name]
+          let res = await cls_chain.add_config(config.class_.methods[name])
+          config.class_.methods[name] = `${met.address}/${met._id}`
+        }
+        result = await cls_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])
+        for (let b=0; b< config.blocks.length; b++){
+          let blk = config.blocks[b]
+          blk.predicate = await this.add_config(blk.predicate)
+          for (let d = 0; d <blk.body.length; d++){
+            blk.body[d] = await this.add_config(blk.body[d])
           }
         }
         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)
+        if (config.loop_type === 'for'){
           config.update = await this.add_config(config.update)
+          config.iterator = await this.add_config(config.iterator)
         }
+        config.condition = await this.add_config(config.condition)
 
         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 'assignment':
+        config.value = await this.add_config(config.value)
+        result = await (await this.chain(`${this.address}/${config.identifier}`)).write_config(config)
+        break;
+      case 'nest':
+        let n_chain = await this.chain(config.location)
+        for (let n=0; n < config.nests.length; n++){
+          config.nests[n] = await n_chain.add_config(config.nests[n])
+        }
+        result = await n_chain.write_config(config)
+        break;
+      case 'return':
+        config.output = await this.add_config(config.output)
+        result = 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_chn = await this.chain(config.location)
+        if (config.identifier.type === 'nest'){
+          config.identifier = await (await this.chain(config.identifier.location)).write_config(config.identifier)
         }
-        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])
+        for (let a=0; a < config.arguments.length; a++){
+          let arg = config.arguments[a]
+          let chn = await this.chain(arg.location)
+          config.arguments[a] = await chn.add_config(arg)
         }
-        result = await call_chain.write_config(config)
+        result = await call_chn.write_config(config)
+        break
+      case 'adm':
+        console.log(config)
+        let adm_chain = await this.chain(config.location)
+        result = await adm_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])
+      case 'trycatch':
+        let try_chain = await this.chain(config.location)
+        
+        for (let i=0; i < config.try_body.length; i++){
+          let tbd = config.try_body[i]
+          config.try_body[i] = await try_chain.add_config(tbd)
         }
-        if(config.assignment)
-          config.assignment = await nest_chain.add_config(config.assignment)
-
-        result = await nest_chain.write_config(config)
+        for (let i=0; i < config.catch_body.length; i++){
+          let tbd = config.catch_body[i]
+          config.catch_body[i] = await try_chain.add_config(tbd)
+        }
+        result = await try_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'){
+      case 'raise':
+        let raise_chain = await this.chain(config.location)
+        config.object = await raise_chain.add_config(config.object)
+        result = raise_chain.write_config(config)
+        break
+      default:
+        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)
+        }else if (this.account.vm.datatypes.includes(config.type)){
+          if (config.type === 'array'){
+            for (let i=0; i< config.value.length; i++){
+              config.value[i] = await this.add_config(config.value[i])
+            }
+          } else if (config.type === 'twain'){
+            for (let key in config.value){
+              let pair = config.value[key]
+              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 (['break', 'continue'].includes(config.type)){
-          result = config;
+          let d_chain = await this.chain(config.location)
+          result = await d_chain.write_config(config)
+        } else if (['variable', 'reference'].includes(config.type)) {
+          result = config
+        } else if (['continue', 'break'].includes(config.type)) {
+          result = config
         }
-
     }
 
     return result;
   }
-
 }
 
-export default Folder;
+export default Chain;