godprotocol 1.1.32 → 1.2.0

package/Objects/Datatypes.js

@@ -1,620 +1,146 @@
-class Datatypes{
+class Datatypes {
+  constructor(){}
 
-  string = async(op, args)=>{
-    let me = await this.literal(),
-    other = args[0], result=null;
-
-    console.log(op)
-    switch(op){
-      case 'upper':
-        result = me.toUpperCase()
-        break;
-      case 'lower':
-        result = me.toLowerCase()
-        break;
-      case 'title':
-        result = "";
-        me = me.split(' ').map(m=>{
-          result = `${result} ${m[0].toUpperCase()}${m.slice(1).toLowerCase()}`.trim()
-        })
-        break;
-      case 'slice':
-        let start = args[0], end = args[1];
-        start = start && await start.literal()
-        end = end && await end.literal()
-
-        result = me.slice(start, end)
-        break;
-      case 'concat':
-        other = await args[0].literal()
-        result = `${me}${other}`
-        break;
-      case 'find':
-        let lst = args[1] && await args[1].literal()
-        result = me[lst?'lastIndexOf': 'indexOf'](await other.literal())
-        break;
-      case 'includes':
-        result = me.includes(await other.literal())
-        break;
-      case 'index':
-        other = await other.literal()
-        if (other < 0){
-          result = me.slice(other)[0]
-        }else result = me[other]
-        break;
-      case 'trim':
-        other = args[0]
-        if (other) other = await other.literal()
-        else other = 0
-        let char = args[1]
-        if (char) char = await char.literal()
-        else char = ' '
-
-        let esc_regx_char = (char) => char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-        let char_regx = esc_regx_char(char);
-
-        switch (other) {
-          case 1:
-            result = me.replace(new RegExp(`^${char_regx}+`), '');
-            break
-          case 2:
-            result = me.replace(new RegExp(`${char_regx}+$`), '');
-            break
-          case 0:
-          default:
-            result = me.replace(new RegExp(`^${char_regx}+|${char_regx}+$`, 'g'), '');
-        }
-        break;
-      case 'length':
-        result = me.length;
-        break;
-      case 'is_empty':
-        result = !!me
-        break;
-      case 'is_blank':
-        result = !!me.trim()
-        break;
-      case 'is_numeric':
-        result = !!me && !isNaN(Number(me))
-        break;
-      case "endswith":
-        result = me.endsWith(await other.literal())
-        break;
-      case "startswith":
-        result = me.startsWith(await other.literal())
-        break;
-      case 'padend':
-        result = me.padEnd(await other.literal(), await args[1].literal())
-        break;
-      case 'padstart':
-        result = me.padStart(await other.literal(), await args[1].literal())
-        break;
-      case 'count':
-        other = await args[0].literal()
-
-        let count = 0;
-        let position = 0;
-
-        while ((position = me.indexOf(other, position)) !== -1) {
-          count++;
-          position += other.length;
-        }
-        result = count;
-        break;
-      case 'reverse':
-        result = me.split('').reverse().join('');
-        break
-      case 'repeat':
-        result = me.repeat(await other.literal())
-        break
-      case 'replace':
-        let globally = args[2] && await args[2].literal(),
-        keyword = await other.literal(), replacement = await args[1].literal()
-        result = me.replace(keyword, replacement)
-        if (globally){
-          while(result.includes(keyword)) result = result.replace(keyword, replacement)
-        }
-        break
-      case 'split':
-        other = other ? await other.literal(): ' '
-        result = me.split(other)
-        break
-      case 'charcode':
-        let code = args[1] ? await args[1].literal() : 'ascii'
-        if (code === 'ascii'){
-          result = me.split("").map(char => char.charCodeAt(0))
-        }
-        
-        break;
+  insert = async({arr, item, index})=>{
+    let folder = await this.folder()
+    
+    if (index === arr.length){
+      let item_folder = await folder.folder(index.toString())
+
+      let res = await item_folder.write(item, {replace: true})
+      arr.length ++
+      arr.value = res.datapath
+    }else {
+      let ref;
+      while (index <= arr.length){
+        let item_folder = await folder.folder(index.toString())
+        let curr_item = await item_folder.readone()
+        ref = await item_folder.write(item, {replace: true})
+        item = curr_item
+        index ++
+      }
+      arr.length ++
+      arr.value = ref.datapath
     }
 
-    return result
+    await folder.write(arr, {replace: true})
   }
 
-  number = async (op, args)=>{
-    let other = args[0]
-
-    other = other && await other.literal()
-    let me = await this.literal()
+  pop = async({arr, index})=>{
+    let folder = await this.folder(), popped;
     
-    let result;
-    switch(op){
-      case '__add__':
-        result = me + other;
-        break;
-      case '__sub__':
-        result = me - other;
-        break;
-      case '__mul__':
-        result = me * other;
-        break;
-      case '__div__':
-        if (!other)result = { error:true, value:{name: 'ZeroDivision'}}
-        else result = me / other;
-        break;
-      case '__exp__':
-        result = me ** other;
-        break;
-      case '__floordiv__':
-        result = Math.floor(me / other);
-        break;
-      case '__mod__':
-        result = me % other;
-        break;
-      case '__eq__':
-        result = me === other
-        break;
-      case '__ne__':
-        result = me !== other
-        break;
-      case '__lt__':
-        result = me < other
-        break;
-      case '__lte__':
-        result = me <= other
-        break;
-      case '__gt__':
-        result = me > other
-        break;
-      case '__gte__':
-        result = me >= other
-        break;
-      case 'abs':
-        result = Math.abs(me)
-        break;
-      case 'sqrt':
-        result = Math.sqrt(me)
-        break;
-      case 'to_int':
-        result = parseInt(me)
-        break;
-      case 'to_float':
-        result = Number(me).toFixed(other)
-        break;
-      case 'to_string':
-        result = me.toString()
-        break;
-      case 'tan':
-        result = Math.tan(me)
-        break;
-      case 'sin':
-        result = Math.sin(me)
-        break;
-      case 'cos':
-        result = Math.cos(me)
-        break;
-      case 'atan':
-        result = Math.atan(me)
-        break;
-      case 'atan2':
-        result = Math.atan2(me)
-        break;
-      case 'asin':
-        result = Math.asin(me)
-        break;
-      case 'acos':
-        result = Math.acos(me)
-        break;
-      case 'tanh':
-        result = Math.tanh(me)
-        break;
-      case 'sinh':
-        result = Math.sinh(me)
-        break;
-      case 'cosh':
-        result = Math.cosh(me)
-        break;
-      case 'asinh':
-        result = Math.asinh(me)
-        break;
-      case 'acosh':
-        result = Math.acosh(me)
-        break;
-      case 'atanh':
-        result = Math.atanh(me)
-        break;
-      case 'round':
-        if (other){
-          result = Number(Number(me).toFixed(other))
-        }else result = Math.round(me)
-        break;
-      case 'ceil':
-        result = Math.ceil(me)
-        break;
-      case 'floor':
-        result = Math.floor(me)
-        break;
-      case 'is_prime':
-        if (me <= 1) result = false;
-        if (me <= 3) result = true;
-        
-        if (me % 2 === 0 || me % 3 === 0) result = false; 
-        
-        for (let i = 5; i * i <= me; i += 6) {
-          if (me % i === 0 || me % (i + 2) === 0) {
-            result = false;
-          }
-        }
-        result = true;
-        break;
-      case 'is_odd':
-        result = (me % 2) === 1
-        break
-      case 'is_even':
-        result = (me % 2) === 0
-        break
-      case 'log':
-        if (!other || (other === 10))
-          result = Math.log10(me)
-        else if (other === Math.E){
-          result = Math.log(me)
-        }else result = Math.log(me) / Math.log(other)
-        break;
-      case 'factorial':
-        result = this.factorial(me)
-        break;
-      case 'is_perfect_square':
-        if (me < 0) result = false; 
-        
-        let sqrt = Math.sqrt(me);
-        result = sqrt === Math.floor(sqrt);
-        break
-      case 'to_degrees':
-        result = me * (180 / Math.PI)
-        break;
-      case 'to_radians':
-        result = me * (Math.PI / 180)
-        break;
+    while (index < arr.length){
+      let index_folder = await folder.folder(index.toString())
+
+      if (!popped){
+        popped = await index_folder.readone()
+      }
+      index++
+      if (index < arr.length){
+        let next_item = await folder.folder(index.toString())
+        next_item = await next_item.readone()
+        await index_folder.write(next_item, {replace: true})
+      }
     }
-
-    return result    
-  }
-
-  array = async(op, args, options={})=>{
-    let {config, chain } = options;
     
-    await this.literal()
-    let other = args[0], store, result = null;
+    arr.length --
 
-    switch(op){
-      case 'push':
-        result = this.lit.content_addr.push(other.value.path)
-        store = true;
-        break;
-      case 'length':
-        result = this.lit.content.length;
-        break;
-      case 'pop':
-        if (other){
-          result = this.lit.content_addr.splice(await other.literal(), 1)[0]
-        }else result = this.lit.content_addr.pop()
-        
-        store= true
+    await folder.write(arr, {replace: true})
+    return popped
+  }
 
-        if(result){
-          result = {type:'address',value: result}
-        }
-        break;
-      case 'extend':
-        await other.literal()
-        result = this.lit.content_addr.push(...other.lit.content_addr)
-        store = true
-        
-        break;
-      case 'slice':
-        let start = args[0] && await args[0].literal()
-        let end = args[1] && await args[1].literal()
+  index = async ({i}) => {
+    let folder = await this.folder()
 
-        let new_arr = this.lit.content_addr.slice(start, end)
-        result = new_arr
+    let item_folder = await folder.folder(i.toString())
+    return (await item_folder.readone())
+  }
 
-        let res = await this.account.vm.instantiate({type:'array', value: result, location: config.location}, {chain, pure: true})
+  get = async({twa, key})=>{
+    let folder = await this.folder()
 
-        result = {type:'address', value: res}
-        break;
-      case 'splice':
-        let spl_replacement = args[2]
-        if (spl_replacement){
-          result = this.lit.content_addr.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal(), spl_replacement.value.path )
-        }else result = this.lit.content_addr.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal())
-        
-        store = true;
+    let child = await folder.folder(key)
+    let res = (await child.readone())
 
-        result = {type:'address', value: await this.account.vm.instantiate({type:'array', value: result, location: config.location}, {chain, pure: true})}
+    if(!res) return null;
 
-        break;
-      case 'index':
-        other = await other.literal()
-        if (typeof other === 'number'){
-          if (other <0){
-            result = this.lit.content_addr.slice(other)[0]
-          }else result = this.lit.content_addr[other];
-        }
-        if (result) result = {type:'address', value: result}
-        break;
-      case 'to_string':
-        other = other && await other.literal()
+    if (res.deleted) res = null
 
-        result = ''
-        for (let i=0; i< this.lit.content_addr.length; i++){
-          let item = this.lit.content_addr[i];
+    return res.value;
+  }
 
-          let cont = await this.account.vm.resolve_address(item);
-          cont = await this.account.vm.cloth_content(cont)
-          cont = await cont.literal()
-          if (other === 'ascii'){
-            if (typeof cont === 'number'){
-              result = `${result}${String.fromCharCode(cont)}`
-            }else result = `${result}void`
-          }else result = `${result}${cont}`
-        }
-        break;
-      case 'is_empty':
-        result = !this.lit.content_addr.length
-        break;
-      case 'clear':
-        this.lit.content_addr = []
-        store = true;
-        break
-      case "join":
-        let str_val = ''
-        let separator = (other && await other.literal()) || ','
-        for (let i=0; i< this.lit.content_addr.length; i++){
-          let item = this.lit.content_addr[i]
-          let val = await this.account.vm.cloth_content(await this.account.vm.resolve_address(item))
+  set = async({twa, key, prop, value}) => {
+    let folder = await this.folder()
+    let pair_folder = await folder.folder(key)
+    let {vm} = this.account;
+    
+    await (await pair_folder.folder('__prop__')).write(prop)
 
-          let cont = await val.literal()
-          if (['number', 'string', 'void', 'boolean'].includes(typeof cont))str_val = `${str_val}${i ? separator: ''}${cont}`
-        }
-        result = str_val
-        break;
-      case 'map':
-        let confg = other.value;
-        let map_arr = []
-        for (let i=0; i< this.lit.content_addr.length; i++){
-          let item = this.lit.content_addr[i];
-          
-          let res = await this.account.vm.execute(confg, {call_config: {
-            identifier: confg.address,
-            arguments: [
-              {type:'address', value: item, position: 0},
-              {...await this.account.vm.parse_aircode(i, {config, chain}), position:1}
-            ],
-            location: config.location
-          }, chain})
-          if (res && res.type!== 'address'){
-            console.log("Datatypes.js:Query")
-          }
-          map_arr.push(res.value)
-        }
-        if (args[1] && await args[1].literal()){
-          this.lit.content_addr = map_arr
-          store = true
-        }else result = {type:'address', value: await this.account.vm.instantiate({type:'array', value: map_arr, location: config.location}, {chain, pure: true})}
-        
-        break;
-      case 'filter':
-        let fconfg = other.value;
-        let fil_arr = []
-        for (let i=0; i< this.lit.content_addr.length; i++){
-          let item = this.lit.content_addr[i];
-          
-          let res = await this.account.vm.execute(fconfg, {call_config: {
-            identifier: fconfg.address,
-            arguments: [
-              {type:'address', value: item, position: 0},
-              {...await this.account.vm.parse_aircode(i, {config, chain}), position:1}
-            ],
-            location: config.location
-          }, chain, cloth: true})
-          
-          if (res && !!await res.literal())
-            fil_arr.push(item)
-        }
-        if (args[1] && await args[1].literal()){
-          this.lit.content_addr = fil_arr
-          store = true
-        }else result = {
-          type:'address', 
-          value: await this.account.vm.instantiate({
-            type:'array', 
-            value: fil_arr, 
-            location: config.location}, 
-            {chain, pure: true})
-        }
+    let prev = (await pair_folder.readone()), addr;
+    
+    if (prev && prev.created < twa.created) prev = null
+    if (prev && prev.deleted) prev = null
+
+    if (!prev){
+      if (twa.value){
+        let o = this._split_datapath(twa.value)
+        o = {value: o[0], _id: o[1], type: 'address'}
+        prev = await vm.cloth(o, {just_content: true})
+        prev = await vm.cloth_content(prev.value)
+
+        let res = await pair_folder.write({value, prev: twa.value}, {replace: true})
+        addr = res.datapath
         
-        break;
-      case 'find':
-        let fnconfg = other.value;
-        for (let i=0; i< this.lit.content_addr.length; i++){
-          let item = this.lit.content_addr[i];
-          
-          let index = await this.account.vm.parse_aircode(i, {config, chain})
-          let res = await this.account.vm.execute(fnconfg, {call_config: {
-            identifier: fnconfg.address,
-            arguments: [
-              {type:'address', value: item, position: 0},
-              {...index, position:1}
-            ],
-            location: config.location
-          }, chain, cloth: true})
-          
-          if (res && !!await res.literal())
-            {
-            result = index
-            break
-            }
-        }
-      case 'includes':
-        other = await other.literal()
-        for (let i=0; i< this.lit.content_addr.length; i++){
-          let item = this.lit.content_addr[i];
-          let val = await this.account.vm.cloth_content(await this.account.vm.resolve_address(item))
-
-          if (await val.literal() === other){
-            result = true;
-            break
-          }
-        }
-        result = result || false
-        break;
-      case 'copy':
-        result = {
-          type:'address', 
-          value: await this.account.vm.instantiate({
-            type:'array', 
-            value: [...this.lit.content_addr], 
-            location: config.location}, 
-            {chain, pure: true})
-        }
-        break;
-      case 'reverse':
-        this.lit.content_addr.reverse()
-        store = true
-        break;
+        let p_folder = await this.account.manager.ds.folder(`${o.value}`)
+        await p_folder.update({_id: o._id}, {next: addr})
+      }else {
+        addr = await pair_folder.write({value}, {replace: true})
+        addr = addr.datapath
+      }
+      twa.value = addr
+      await folder.write(twa, {replace: true})
+      return addr;
     }
 
-    if (store) {
-      let oracle = this.account.manager.oracle
-      let obj = {content: JSON.stringify(this.lit.content_addr), __classifier__: 'array', uid: this.lit.uid}
-      
-      let path_split = this.value.path.split('/')
-      await oracle.fs.store(obj, {path: path_split.slice(0,-1).join('/'), hash: path_split[path_split.length-1], is_instance: true, type: 'twain'})
-    }
-
-    return result
+    await pair_folder.update({_id: prev._id}, {value})
   }
 
-  twain = async(op, args, options)=>{
-    let {config, chain} = options
-    await this.literal()
-
-    let result = null, store, other = args[0];
-    switch(op){
-      case 'entries':
-        result = []
-        for (let p in this.lit.content_addr){
-          let pair = this.lit.content_addr[p]
-
-          result.push(await this.account.vm.instantiate({
-            type:'array', 
-            value: pair, 
-            location: config.location}, 
-            {chain, pure: true}))
-        }
-        result = {type:'address', value: await this.account.vm.instantiate({
-          type:'array', 
-          value: result, 
-          location: config.location}, 
-          {chain, pure: true})
-        }
-        break;
-      case 'keys':
-        result = []
-        for (let p in this.lit.content_addr){
-          let pair = this.lit.content_addr[p]
-
-          result.push(pair[0])
-        }
-        result = {type:'address', value: await this.account.vm.instantiate({
-          type:'array', 
-          value: result, 
-          location: config.location}, 
-          {chain, pure: true})
-        }
-        break;
+  _split_datapath = (datapath)=>{
+    datapath = datapath.split('/')
 
-      case 'values':
-        result = []
-        for (let p in this.lit.content_addr){
-          let pair = this.lit.content_addr[p]
+    return [datapath.slice(0,-1).join('/'), datapath.slice(-1)[0]]
+  }
 
-          result.push(pair[1])
-        }
-        result = {type:'address', value: await this.account.vm.instantiate({
-          type:'array', 
-          value: result, 
-          location: config.location}, 
-          {chain, pure: true})
-        }
-        break;
-      case 'get':
-        if(typeof other === 'string'){}
-        else other = other && await other.literal()
+  remove = async({twa, key})=>{
+    let {folder:fold} = this.account.manager.ds
+    let folder = await this.folder()
+    let child = await folder.folder(key)
 
-        let hash = await this.account.manager.oracle.hash(other, 'sha1')
-        let val = this.lit.content_addr[hash]
-        if (val)result = {type: 'address', value: val[1]}
-        break;
-      case 'set':
-        other = other && await other.literal()
-        let shash = await this.account.manager.oracle.hash(other, 'sha1')
-        
-        this.lit.content_addr[shash] = [args[0].value.path, args[1].value.path]
-        store = true;
-        break;
-      case 'remove':
-        other = other && await other.literal()
-        let rhash = await this.account.manager.oracle.hash(other, 'sha1')
-        let rval = this.lit.content_addr[rhash]
-        if(rval)result = true
-        else result = false;
-        
-        delete this.lit.content_addr[rhash]
-        store = true;
-        break
-      case 'copy':
-        result = {type:'address', value: await this.account.vm.instantiate({
-          type:'twain', 
-          value: this.lit.content_addr, 
-          location: config.location}, 
-          {chain, pure: true})
-        }
-        break;
-      case 'clear':
-        this.lit.content_addr = {}
-        store = true;
-        break
+    let val = await child.readone()
+    if (!val || (val && val.deleted)) return false;
 
+    await child.update({_id: val._id}, {deleted: true})
+    
+    if (val.prev){
+      let o = this._split_datapath(val.prev)
+      let pv = await fold(o[0])
+      await pv.update({_id: o[1]}, {next: val.next})
     }
-
-    if (store) {
-      let oracle = this.account.manager.oracle
-      let obj = {content: JSON.stringify(this.lit.content_addr), __classifier__: 'twain', uid: this.lit.uid}
-      
-      let path_split = this.value.path.split('/')
-      await oracle.fs.store(obj, {path: path_split.slice(0,-1).join('/'), hash: path_split[path_split.length-1], is_instance: true, type: 'twain'})
+    if (val.next){
+      let o = this._split_datapath(val.next)
+      let nx = await fold(o[0])
+      await nx.update({_id: o[1]}, {prev: val.prev})
     }
-
-    return result
-  }
-
-  factorial = (value)=>{
-    if (value === 0)
-      return 1
-    return value * this.factorial(value - 1)
+    
+    if (twa.value && twa.value.startsWith(child.address)){
+      if (val.next){
+        console.log("RAISE AN EYEBROW - Datatypes.remove")
+      }
+      twa.value = val.prev
+    }
+    await folder.write(twa, {replace: true})
+    return true;
   }
 }
 
-export default Datatypes;
+export default Datatypes;