zensh/lib/cell.js

A javascript neural network: self-referential, evolution, interconnection...

// **Github:** https://github.com/zensh/zensh
//
// **License:** MIT

/* global module, define */
var thunks = require('thunks'),
  JSONKit = require('jsonkit'),
  md5 = require('blueimp-md5');

module.exports = zenshFactory(thunks, JSONKit, md5);

function zenshFactory(thunks, JSONKit, md5) {
  var Thunk = thunks(),
    toString = Object.prototype.toString,
    hasOwnProperty = Object.prototype.hasOwnProperty,
    zenshTpl = {
      SID: '',
      UID: '',
      pedigree: [],
      birth: '',
      updated: '',
      active: 0,
      nervous: {},
      memory: {}
    };

  function isObject(obj) {
    return toString.call(obj) === '[object Object]';
  }

  function isNewVersion(version, current) {
    current = (current || Zensh.VERSION).replace('v', '').split('.');
    version = version.replace('v', '').split('.');
    for (var i = 0; i < current.length; i++) {
      var val = parseInt(version[i], 10) - parseInt(current[i], 10);
      if (val === 0) continue;
      return val > 0;
    }
    return false;
  }

  function Zensh(zenshJSON) {
    var data;
    try {
      data = JSONKit.intersect(JSONKit.union(zenshTpl), zenshJSON);
    } catch (e) {
      return null;
    }
    if (!(data && data.SID && data.SID.length === 24)) return null;
    JSONKit.union(this, zenshTpl, data);
    JSONKit.removeItem(this.pedigree, '');
    this.birth = this.updated = new Date().toISOString();
    if (data.UID) this.pedigree.push(this.SID + data.UID);
    this.UID = this.genUID();
    this.initNervous();
    this.initMemory();
  }

  Zensh.prototype.initNervous = function() {
    //TODO
  };

  Zensh.prototype.initMemory = function() {
    //TODO
  };

  Zensh.prototype.genUID = function() {
    var uid = md5(this.birth, Math.random()).slice(16);
    while (uid === this.UID || this.nervous[this.SID + uid]) {
      uid = this.genUID();
    }
    return uid;
  };

  Zensh.prototype.run = function(any) {
    if (typeof input === 'string') {
      try {
        any = JSON.parse(input);
      } catch (e) {}
    }
    if (isObject(any) && any.original && any[any.original]) this.update(any);
    return Thunk(function (callback) {
      //TODO
    });
  };

  Zensh.prototype.update = function (nervousList) {
    //TODO
  };

  Zensh.prototype.serializeMemory = function () {
    var memory = {};

    JSONKit.each(this.memory, function (val, key) {
      var type = typeof val;
      if (!val) memory[key] = val;
      else if (val.UID && this.nervous[val.UID]) memory[key] = val.UID;
      else if (type === 'function') memory[key] = val.toString();
      else if (type === 'object') {
        if (Array.isArray(val) || isObject(obj)) memory[key] = val;
        else memory[key] = val.toString();
      } else memory[key] = val;
    }, this, false);

    return memory;
  };

  Zensh.prototype.serializeNervous = function (nervousList) {
    var nervous = {};

    JSONKit.each(this.nervous, function (val, key) {
      if (!nervousList[key]) val.toJSON(nervousList);
      nervous[key] = true;
    }, this, false);

    return nervous;
  };

  Zensh.prototype.toJSON = function (nervousList) {
    var data = {
      SID: this.SID,
      UID: this.UID,
      pedigree: this.pedigree,
      birth: this.birth,
      updated: this.updated,
      active: this.active,
      nervous: this.serializeNervous(nervousList),
      memory: this.serializeMemory()
    };
    try {
      data = JSON.stringify(data);
      nervousList[this.SID + this.UID] = data;
    } catch (e) {}
    return nervousList;
  };

  Zensh.prototype.toString = function () {
    return JSON.stringify(this.toJSON({
      original: this.SID + this.UID,
      sourceVersion: Zensh.VERSION,
      source: zenshFactory.toString()
    }));
  };

  Zensh.NAME = 'Zensh';
  Zensh.VERSION = 'v0.0.1';
  return Zensh;
}