mixin dependencies

withMemDB.js

"use strict";

define(
  function() {

    function withMemDB() {
      var __memdb__ = {};
      var IDLEN = 10;

      function cid()
      {
        var id = "";
        var chars = "abcdefghijklmnopqrstuvwxyz0123456789";

        for( var i=0; i < IDLEN; i++ )
          id += chars.charAt(Math.floor(Math.random() * chars.length));

        return id;
      }

      function p2op(pred) {
        if (pred === 'g') return function(x,y) {return x > y};
        if (pred === 'ge') return function(x,y) {return x >= y};
        if (pred === 'l') return function(x,y) {return x < y};
        if (pred === 'le') return function(x,y) {return x <= y};
        if (pred === 'eq') return function (x,y) {return x === y};
        if (pred === 'neq') return function (x,y) {return x !== y};
        throw "unknown predicate: "+pred;
      }

      function process(dbname, spos, fn) {
        var db = __memdb__[dbname];
        for (var id in db) {
          var doc = db[id];
          var flag = true;
          for (var j = 0, k = spos.length; j < k; j++) {
            var spo = spos[j];
            if (!doc[spo[0]] || !p2op(spo[1])(doc[spo[0]], spo[2])) {
              flag = false;
              break;
            }
          }
          if (flag) {
            fn(db,id);
          }
        }
      }

      function e_db(dbname) {
        if (!__memdb__[dbname]) throw "database " + dbname + " does not exist";
  return true;
      }

      function ne_db(dbname) {
	if (__memdb__[dbname]) throw "database " + dbname + " exists";
        return true;
      }

      function e_doc(dbname, id) {
	if (!__memdb__[dbname][id]) throw "document " + __memdb__[dbname][id] + " does not exists";
        return true;
      }

      function ne_doc(dbname, id) {
        if (__memdb__[dbname][id]) throw "document " + __memdb__[dbname][id] + " exists";
	return true;
      }
      
      this.memDB = {
        create: function(dbname) {
          ne_db(dbname) && (__memdb__[dbname] = {});
        },
        drop: function(dbname) {
          e_db(dbname) && (function() {
            delete __memdb__[dbname]
          })();
        },
        del: function(dbname, spos) {
          e_db(dbname) && (function() {
            process(dbname, spos, function(db,id) {delete db[id]});
          })();
        },
        query: function(dbname, spos, opt_order_by, opt_asc) {
          return e_db(dbname) && (function() {
            var acc = [];
            process(dbname, spos, function(db,id) {acc.push(db[id])});
            if (opt_order_by) {
              acc.sort(function(x,y){return opt_asc
                                     ? x[opt_order_by] < y[opt_order_by]
                                     : x[opt_order_by] > y[opt_order_by]});
            }
            return acc;
          })();
        },
        put: function(dbname, doc) {
          var id = doc.id ? doc.id : cid();
          return e_db(dbname) && ne_doc(dbname, id) && (function() {
            __memdb__[dbname][id] = doc;
            return doc;
          })();
        },
        get: function(dbname, id) {
          return e_db(dbname) && e_doc(dbname, id) && (function() {
            return __memdb__[dbname][id];
          })();
        },
        update: function(dbname, doc) {
          return e_db(dbname) && e_doc(dbname, doc.id) && (function() {
            __memdb__[dbname][doc.id] = doc;
            return doc;
          })();
        }
      };
    }
    return withMemDB;
  }
);

withTemplate.js

this.after('initialize', function() {
        var self = this;
        if (!self.memDB) throw "memDB not found";
        ...
        processTemplates(self.attr.template_files_);
}