major change to cryptostorage and all storages now support callbacks

src/jio.js

@@ -209,42 +209,24 @@
     }
   }
 
-  function ensurePushableQueue(callback, argument_list, context) {
-    var result;
-    try {
-      result = callback.apply(context, argument_list);
-    } catch (e) {
-      return new RSVP.Queue()
-        .push(function returnPushableError() {
-          return RSVP.reject(e);
-        });
-    }
-    if (result instanceof RSVP.Queue) {
-      return result;
-    }
-    return new RSVP.Queue()
-      .push(function returnPushableResult() {
-        return result;
-      });
-  }
-
   function declareMethod(klass, name, precondition_function, post_function) {
     klass.prototype[name] = function () {
       var argument_list = arguments,
         context = this,
-        precondition_result,
-        storage_method,
-        queue;
+        precondition_result;
 
-      // Precondition function are not asynchronous
+      return new RSVP.Queue()
+        .push(function () {
           if (precondition_function !== undefined) {
-        precondition_result = precondition_function.apply(
+            return precondition_function.apply(
               context.__storage,
               [argument_list, context, name]
             );
           }
-
-      storage_method = context.__storage[name];
+        })
+        .push(function (result) {
+          var storage_method = context.__storage[name];
+          precondition_result = result;
           if (storage_method === undefined) {
             throw new jIO.util.jIOError(
               "Capacity '" + name + "' is not implemented on '" +
@@ -252,21 +234,22 @@
               501
             );
           }
-      queue = ensurePushableQueue(storage_method, argument_list,
-                                  context.__storage);
-
-      if (post_function !== undefined) {
-        queue
+          return storage_method.apply(
+            context.__storage,
+            argument_list
+          );
+        })
         .push(function (result) {
+          if (post_function !== undefined) {
             return post_function.call(
               context,
               argument_list,
               result,
               precondition_result
             );
-          });
           }
-      return queue;
+          return result;
+        });
     };
     // Allow chain
     return this;
@@ -298,7 +281,8 @@
   JioProxyStorage.prototype.post = function () {
     var context = this,
       argument_list = arguments;
-    return ensurePushableQueue(function () {
+    return new RSVP.Queue()
+      .push(function () {
         var storage_method = context.__storage.post;
         if (storage_method === undefined) {
           throw new jIO.util.jIOError(
@@ -425,8 +409,13 @@
         501
       );
     }
-    return ensurePushableQueue(storage_method, argument_list,
-                               context.__storage);
+    return new RSVP.Queue()
+      .push(function () {
+        return storage_method.apply(
+          context.__storage,
+          argument_list
+        );
+      });
   };
 
   JioProxyStorage.prototype.hasCapacity = function (name) {
@@ -450,7 +439,8 @@
     if (options === undefined) {
       options = {};
     }
-    return ensurePushableQueue(function () {
+    return new RSVP.Queue()
+      .push(function () {
         if (context.hasCapacity("list") &&
             ((options.query === undefined) || context.hasCapacity("query")) &&
             ((options.sort_on === undefined) || context.hasCapacity("sort")) &&
@@ -459,7 +449,9 @@
             ((options.include_docs === undefined) ||
              context.hasCapacity("include")) &&
             ((options.limit === undefined) || context.hasCapacity("limit"))) {
-        return context.buildQuery(options)
+          return context.buildQuery(options);
+        }
+      })
       .push(function (result) {
         return {
           data: {
@@ -468,8 +460,6 @@
           }
         };
       });
-      }
-    });
   };
 
   declareMethod(JioProxyStorage, "allAttachments", checkId);
@@ -478,7 +468,8 @@
   JioProxyStorage.prototype.repair = function () {
     var context = this,
       argument_list = arguments;
-    return ensurePushableQueue(function () {
+    return new RSVP.Queue()
+      .push(function () {
         var storage_method = context.__storage.repair;
         if (storage_method !== undefined) {
           return context.__storage.repair.apply(context.__storage,

src/jio.storage/cryptstorage.js

 /*
  * Copyright 2015, Nexedi SA
- * Released under the LGPL license.
- * http://www.gnu.org/licenses/lgpl.html
- */
+* Released under the LGPL license.
+   * hcrypto, Uint8Array, ArrayBuffer*/
 
 /*jslint nomen: true*/
-/*global jIO, RSVP, DOMException, Blob, crypto, Uint8Array, ArrayBuffer*/
-
-(function (jIO, RSVP, DOMException, Blob, crypto, Uint8Array, ArrayBuffer) {
+/*global jIO, RSVP, DOMParser, Blob, DOMException, crypto, Uint8Array,
+  ArrayBuffer, CryptoKey*/
+/*jslint maxlen: 160 */
+(function (jIO, RSVP, DOMException, Blob, crypto, Uint8Array, ArrayBuffer, CryptoKey) {
   "use strict";
 
   /*
   The cryptography system used by this storage is AES-GCM.
-  Here is an example of how to generate a key to the json format:
+  Here is an example of how to generate a strong user key :
+
+  go to the website : https://randomkeygen.com/  pike a key and memorize it
 
   return new RSVP.Queue()
     .push(function () {
-      return crypto.subtle.generateKey({name: "AES-GCM", length: 256},
-                                       true, ["encrypt", "decrypt"]);
-    })
-    .push(function (key) {
-      return crypto.subtle.exportKey("jwk", key);
-    })
-    .push(function (json_key) {
       var jio = jIO.createJIO({
-        type: "crypt",
-        key: json_key,
+        type: "crypt"
         sub_storage: {storage_definition}
       });
     });
@@ -41,26 +35,14 @@
    * @constructor
    */
 
+
   var MIME_TYPE = "application/x-jio-aes-gcm-encryption";
 
-  function CryptStorage(spec) {
-    this._key = spec.key;
-    this._jsonKey = true;
-    this._sub_storage = jIO.createJIO(spec.sub_storage);
-  }
-
-  function convertKey(that) {
-    return new RSVP.Queue()
-      .push(function () {
-        return crypto.subtle.importKey("jwk", that._key,
-                                       "AES-GCM", false,
-                                       ["encrypt", "decrypt"]);
-      })
-      .push(function (res) {
-        that._key = res;
-        that._jsonKey = false;
-        return;
-      });
+  function CryptStorage(spec, utils) {
+    this._utils = utils;
+    this._keyid = spec.keyid;
+    this._key = "";
+    this._sub_storage = jIO.createJIO(spec.sub_storage, utils);
   }
 
   CryptStorage.prototype.get = function () {
@@ -93,18 +75,10 @@
                                               arguments);
   };
 
-
   CryptStorage.prototype.putAttachment = function (id, name, blob) {
     var initializaton_vector = crypto.getRandomValues(new Uint8Array(12)),
       that = this;
-
     return new RSVP.Queue()
-      .push(function () {
-        if (that._jsonKey === true) {
-          return convertKey(that);
-        }
-        return;
-      })
       .push(function () {
         return jIO.util.readBlobAsDataURL(blob);
       })
@@ -114,64 +88,116 @@
           buf = new ArrayBuffer(strLen),
           bufView = new Uint8Array(buf),
           i;
-
         dataURL = dataURL.target.result;
         for (i = 0; i < strLen; i += 1) {
           bufView[i] = dataURL.charCodeAt(i);
         }
         return crypto.subtle.encrypt({
-          name : "AES-GCM",
-          iv : initializaton_vector
+          name: "AES-GCM",
+          iv: initializaton_vector
         },
           that._key, buf);
       })
       .push(function (coded) {
-        var blob = new Blob([initializaton_vector, coded], {type: MIME_TYPE});
+        var blob = new Blob([initializaton_vector, coded], {
+          type: MIME_TYPE
+        });
         return that._sub_storage.putAttachment(id, name, blob);
+      })
+      .push(undefined, function (error) {
+        var cryptoerror = {keyid: that._keyid},
+          callback_crypto = {
+            addkey_crypto: that.addkey.bind(that),
+            error_crypto: cryptoerror
+          };
+        if (that._utils === undefined) {
+          throw new jIO.util.jIOError(that._keyid + ": no callback function declared");
+        }
+        if (!that._utils.hasOwnProperty("crypto_getCryptoKey")) {
+          throw new jIO.util.jIOError(that._keyid + ":crypto_getCryptoKey function not declared in callback");
+        }
+        if (error instanceof DOMException) {
+          if (error.name === "OperationError") {
+            cryptoerror.error_type = error.name;
+            cryptoerror.error_message = "Failed to decrypt due to incorrect password or data";
+          } else if (error.name === "InvalidAccessError") {
+            cryptoerror.error_type = error.name;
+            cryptoerror.error_message = "invalid encryption algorithm, or invalid key for specified encryption algorithm";
+          }
+        } else if (error instanceof TypeError) {
+          cryptoerror.error_type = error.name;
+          cryptoerror.error_message = "password is not type CRYPTOKEY";
+        }
+        return new RSVP.Queue()
+          .push(function () {
+            return that._utils.crypto_getCryptoKey(callback_crypto);
+          })
+          .push(function () {
+            throw new jIO.util.jIOError(that._keyid + " : " + cryptoerror.error_type +
+              " : " + cryptoerror.error_message, 801);
+          });
       });
   };
 
   CryptStorage.prototype.getAttachment = function (id, name) {
     var that = this;
-
     return that._sub_storage.getAttachment(id, name)
       .push(function (blob) {
-        if (blob.type !== MIME_TYPE) {
-          return blob;
-        }
         return new RSVP.Queue()
           .push(function () {
-            if (that._jsonKey === true) {
-              return convertKey(that);
-            }
-            return;
-          })
+            return new RSVP.Queue()
               .push(function () {
                 return jIO.util.readBlobAsArrayBuffer(blob);
               })
               .push(function (coded) {
                 var initializaton_vector;
-
                 coded = coded.target.result;
                 initializaton_vector = new Uint8Array(coded.slice(0, 12));
                 return new RSVP.Queue()
                   .push(function () {
                     return crypto.subtle.decrypt({
-                  name : "AES-GCM",
-                  iv : initializaton_vector
+                      name: "AES-GCM",
+                      iv: initializaton_vector
                     },
                       that._key, coded.slice(12));
                   })
                   .push(function (arr) {
-                //arraybuffer->string
                     arr = String.fromCharCode.apply(null, new Uint8Array(arr));
                     return jIO.util.dataURItoBlob(arr);
                   })
                   .push(undefined, function (error) {
+                    var cryptoerror = {keyid: that._keyid},
+                      callback_crypto = {
+                        addkey_crypto: that.addkey.bind(that),
+                        error_crypto: cryptoerror
+                      };
+                    if (that._utils === undefined) {
+                      throw new jIO.util.jIOError(that._keyid + ": no callback function declared");
+                    }
+                    if (!that._utils.hasOwnProperty("crypto_getCryptoKey")) {
+                      throw new jIO.util.jIOError(that._keyid + ":crypto_getCryptoKey function not declared in callback");
+                    }
                     if (error instanceof DOMException) {
-                  return blob;
+                      if (error.name === "OperationError") {
+                        cryptoerror.error_type = error.name;
+                        cryptoerror.error_message = "Failed to decrypt due to incorrect password or data";
+                      } else if (error.name === "InvalidAccessError") {
+                        cryptoerror.error_type = error.name;
+                        cryptoerror.error_message = "invalid encryption algorithm, or invalid key for specified encryption algorithm";
+                      }
+                    } else if (error instanceof TypeError) {
+                      cryptoerror.error_type = error.name;
+                      cryptoerror.error_message = "password is not type CRYPTOKEY";
                     }
-                throw error;
+                    return new RSVP.Queue()
+                      .push(function () {
+                        return that._utils.crypto_getCryptoKey(callback_crypto);
+                      })
+                      .push(function () {
+                        throw new jIO.util.jIOError(that._keyid + " : " + cryptoerror.error_type
+                          + " : " + cryptoerror.error_message, 801);
+                      });
+                  });
               });
           });
       });
@@ -187,6 +213,32 @@
                                                   arguments);
   };
 
+  CryptStorage.prototype.addkey = function (key) {
+    var that = this;
+    if (key === undefined || key === null) {return; }
+    if (!(key.hasOwnProperty("CryptoKey") && key.hasOwnProperty("Salt"))) {return; }
+    if (!(key.CryptoKey instanceof CryptoKey && key.Salt instanceof ArrayBuffer)) {return; }
+    if (key.CryptoKey.algorithm.name !== "PBKDF2"
+        &&  key.CryptoKey.usages[0] !== "deriveKey") {return; }
+    return new RSVP.Queue()
+      .push(function () {
+        return window.crypto.subtle.deriveKey({
+          "name": "PBKDF2",
+          "salt":  key.Salt,
+          "iterations": 1000,
+          //we can add iteration number but slow CPU will freez
+          "hash": "SHA-256"
+        }, key.CryptoKey, {
+          "name": "AES-GCM",
+          "length": 256
+        }, false, ["encrypt", "decrypt"]);
+      })
+      .push(function (res) {
+        that._key = res;
+      });
+  };
+
+
   jIO.addStorage('crypt', CryptStorage);
 
-}(jIO, RSVP, DOMException, Blob, crypto, Uint8Array, ArrayBuffer));
+}(jIO, RSVP, DOMException, Blob, crypto, Uint8Array, ArrayBuffer, CryptoKey));

src/jio.storage/davstorage.js

@@ -76,11 +76,12 @@
    * @class DavStorage
    * @constructor
    */
-  function DavStorage(spec) {
+  function DavStorage(spec, utils) {
     if (typeof spec.url !== 'string') {
       throw new TypeError("DavStorage 'url' is not of type string");
     }
     this._url = spec.url;
+    this._utils = utils;
     // XXX digest login
     if (typeof spec.basic_login === 'string') {
       this._authorization = "Basic " + spec.basic_login;

src/jio.storage/documentstorage.js

@@ -8,8 +8,9 @@
    * @class DocumentStorage
    * @constructor
    */
-  function DocumentStorage(spec) {
-    this._sub_storage = jIO.createJIO(spec.sub_storage);
+  function DocumentStorage(spec, utils) {
+    this._utils = utils;
+    this._sub_storage = jIO.createJIO(spec.sub_storage, utils);
     this._document_id = spec.document_id;
     this._repair_attachment = spec.repair_attachment || false;
   }

src/jio.storage/drivetojiomapping.js

@@ -9,8 +9,9 @@
    * @class FileSystemBridgeStorage
    * @constructor
    */
-  function FileSystemBridgeStorage(spec) {
-    this._sub_storage = jIO.createJIO(spec.sub_storage);
+  function FileSystemBridgeStorage(spec, utils) {
+    this._utils = utils;
+    this._sub_storage = jIO.createJIO(spec.sub_storage, utils);
   }
   var DOCUMENT_EXTENSION = ".json",
     DOCUMENT_KEY = "/.jio_documents/",

src/jio.storage/dropboxstorage.js

@@ -105,11 +105,12 @@
    * @class DropboxStorage
    * @constructor
    */
-  function DropboxStorage(spec) {
+  function DropboxStorage(spec, utils) {
     if (typeof spec.access_token !== 'string' || !spec.access_token) {
       throw new TypeError("Access Token' must be a string " +
                           "which contains more than one character.");
     }
+    this._utils = utils;
     this._access_token = spec.access_token;
   }
 

src/jio.storage/erp5storage.js

@@ -73,6 +73,8 @@
   };
 
   function extractPropertyFromFormJSON(json) {
+    return new RSVP.Queue()
+      .push(function () {
         var form = json._embedded._view,
           converted_json = {
             portal_type: json._links.type.name
@@ -123,6 +125,7 @@
           result.action_href = form._actions.put.href;
         }
         return result;
+      });
   }
 
   function extractPropertyFromForm(context, id) {
@@ -139,12 +142,13 @@
   }
 
   // XXX docstring
-  function ERP5Storage(spec) {
+  function ERP5Storage(spec, utils) {
     if (typeof spec.url !== "string" || !spec.url) {
       throw new TypeError("ERP5 'url' must be a string " +
                           "which contains more than one character.");
     }
     this._url = spec.url;
+    this._utils = utils;
     this._default_view_reference = spec.default_view_reference;
   }
 

src/jio.storage/fbstorage.js

@@ -11,7 +11,7 @@
         "{+access_token}",
     get_feed_template = UriTemplate.parse(GET_FEED_URL);
 
-  function FBStorage(spec) {
+  function FBStorage(spec, utils) {
     if (typeof spec.access_token !== 'string' || !spec.access_token) {
       throw new TypeError("Access Token must be a string " +
                           "which contains more than one character.");
@@ -20,6 +20,7 @@
       throw new TypeError("User ID must be a string " +
                           "which contains more than one character.");
     }
+    this._utils = utils;
     this._access_token = spec.access_token;
     this._user_id = spec.user_id;
     this._default_field_list = spec.default_field_list || [];

src/jio.storage/gdrivestorage.js

@@ -72,7 +72,7 @@
    * @class GdriveStorage
    * @constructor
    */
-  function GdriveStorage(spec) {
+  function GdriveStorage(spec, utils) {
     if (spec === undefined || spec.access_token === undefined ||
         typeof spec.access_token !== 'string') {
       throw new TypeError("Access Token must be a string " +
@@ -83,6 +83,7 @@
       throw new TypeError("trashing parameter" +
                           " must be a boolean (true or false)");
     }
+    this._utils = utils;
     this._trashing = spec.trashing || true;
     this._access_token = spec.access_token;
     return;

src/jio.storage/gidstorage.js

@@ -283,8 +283,9 @@
    *
    * @class GidStorage
    */
-  function GidStorage(spec) {
+  function GidStorage(spec, utils) {
     var that = this, priv = {};
+    this._utils = utils;
 
     priv.sub_storage = spec.sub_storage;
     priv.constraints = spec.constraints || {

src/jio.storage/httpstorage.js

@@ -3,13 +3,14 @@
 (function (jIO, RSVP, Blob) {
   "use strict";
 
-  function HttpStorage(spec) {
+  function HttpStorage(spec, utils) {
     if (spec.hasOwnProperty('catch_error')) {
       this._catch_error = spec.catch_error;
     } else {
       this._catch_error = false;
     }
     // If timeout not set, use 0 for no timeout value
+    this._utils = utils;
     this._timeout = spec.timeout || 0;
   }
 

src/jio.storage/indexeddbstorage.js

@@ -38,12 +38,13 @@
   // Read only as changing it can lead to data corruption
   var UNITE = 2000000;
 
-  function IndexedDBStorage(description) {
+  function IndexedDBStorage(description, utils) {
     if (typeof description.database !== "string" ||
         description.database === "") {
       throw new TypeError("IndexedDBStorage 'database' description property " +
                           "must be a non-empty string");
     }
+    this._utils = utils;
     this._database_name = "jio:" + description.database;
   }
 

src/jio.storage/indexstorage.js

@@ -427,7 +427,7 @@
    * @class IndexStorage
    * @constructor
    */
-  function IndexStorage(spec) {
+  function IndexStorage(spec, utils) {
     var i;
     if (!Array.isArray(spec.indices)) {
       throw new TypeError("IndexStorage 'indices' must be an array of " +
@@ -451,6 +451,7 @@
                             "'indices[x].index' must be a string array");
       }
     }
+    this._utils = utils;
     this._sub_storage = spec.sub_storage;
   }
 

src/jio.storage/localstorage.js

@@ -24,7 +24,8 @@
 (function (jIO, sessionStorage, localStorage, RSVP) {
   "use strict";
 
-  function LocalStorage(spec) {
+  function LocalStorage(spec, utils) {
+    this._utils = utils;
     if (spec.sessiononly === true) {
       this._storage = sessionStorage;
     } else {

src/jio.storage/memorystorage.js

@@ -29,8 +29,10 @@
    * @class MemoryStorage
    * @constructor
    */
-  function MemoryStorage() {
+  function MemoryStorage(spec, utils) {
+    this._spec = spec; //not used just for compatibility issue 
     this._database = {};
+    this._utils = utils;
   }
 
   MemoryStorage.prototype.put = function (id, metadata) {

src/jio.storage/multisplitstorage.js

@@ -205,8 +205,9 @@
    *
    * @class MultiSplitStorage
    */
-  function MultiSplitStorage(spec) {
+  function MultiSplitStorage(spec, utils) {
     var that = this, priv = {};
+    this._utils = utils;
 
     /**
      * The list of sub storages we want to use to store part of documents.

src/jio.storage/parserstorage.js

@@ -238,11 +238,12 @@
   /////////////////////////////////////////////////////////////
   // Storage
   /////////////////////////////////////////////////////////////
-  function ParserStorage(spec) {
+  function ParserStorage(spec, utils) {
+    this._utils = utils;
     this._attachment_id = spec.attachment_id;
     this._document_id = spec.document_id;
     this._parser_name = spec.parser;
-    this._sub_storage = jIO.createJIO(spec.sub_storage);
+    this._sub_storage = jIO.createJIO(spec.sub_storage, utils);
   }
 
   ParserStorage.prototype.hasCapacity = function (capacity) {

src/jio.storage/qiniustorage.js

@@ -71,7 +71,8 @@
    * @class QiniuStorage
    * @constructor
    */
-  function QiniuStorage(spec) {
+  function QiniuStorage(spec, utils) {
+    this._utils = utils;
     if (typeof spec.bucket !== 'string' && !spec.bucket) {
       throw new TypeError("Qiniu 'bucket' must be a string " +
                           "which contains more than one character.");

src/jio.storage/querystorage.js

@@ -36,8 +36,9 @@
    * @class QueryStorage
    * @constructor
    */
-  function QueryStorage(spec) {
-    this._sub_storage = jIO.createJIO(spec.sub_storage);
+  function QueryStorage(spec, utils) {
+    this._utils = utils;
+    this._sub_storage = jIO.createJIO(spec.sub_storage, utils);
     this._key_schema = {key_set: {}, cast_lookup: {}};
     initKeySchema(this, spec);
   }

src/jio.storage/replicatestorage.js

@@ -53,18 +53,20 @@
     return rusha.digestFromArrayBuffer(content);
   }
 
-  function ReplicateStorage(spec) {
+  function ReplicateStorage(spec, utils) {
+    this._utils = utils;
     this._query_options = spec.query || {};
     if (spec.signature_hash_key !== undefined) {
       this._query_options.select_list = [spec.signature_hash_key];
     }
     this._signature_hash_key = spec.signature_hash_key;
 
-    this._local_sub_storage = jIO.createJIO(spec.local_sub_storage);
-    this._remote_sub_storage = jIO.createJIO(spec.remote_sub_storage);
+    this._local_sub_storage = jIO.createJIO(spec.local_sub_storage, utils);
+    this._remote_sub_storage = jIO.createJIO(spec.remote_sub_storage, utils);
 
     if (spec.hasOwnProperty('signature_sub_storage')) {
-      this._signature_sub_storage = jIO.createJIO(spec.signature_sub_storage);
+      this._signature_sub_storage = jIO.createJIO(spec.signature_sub_storage,
+        utils);
       this._custom_signature_sub_storage = true;
     } else {
       this._signature_hash = "_replicate_" + generateHash(

src/jio.storage/shastorage.js

@@ -16,8 +16,9 @@
 
   var rusha = new Rusha();
 
-  function ShaStorage(spec) {
-    this._sub_storage = jIO.createJIO(spec.sub_storage);
+  function ShaStorage(spec, utils) {
+    this._utils = utils;
+    this._sub_storage = jIO.createJIO(spec.sub_storage, utils);
   }
 
   ShaStorage.prototype.post = function (param) {

src/jio.storage/unionstorage.js

@@ -32,14 +32,15 @@
    * @class UnionStorage
    * @constructor
    */
-  function UnionStorage(spec) {
+  function UnionStorage(spec, utils) {
+    this._utils = utils;
     if (!Array.isArray(spec.storage_list)) {
       throw new jIO.util.jIOError("storage_list is not an Array", 400);
     }
     var i;
     this._storage_list = [];
     for (i = 0; i < spec.storage_list.length; i += 1) {
-      this._storage_list.push(jIO.createJIO(spec.storage_list[i]));
+      this._storage_list.push(jIO.createJIO(spec.storage_list[i], utils));
     }
   }
 

src/jio.storage/uuidstorage.js

@@ -8,8 +8,9 @@
    * @class UUIDStorage
    * @constructor
    */
-  function UUIDStorage(spec) {
-    this._sub_storage = jIO.createJIO(spec.sub_storage);
+  function UUIDStorage(spec, utils) {
+    this._utils = utils;
+    this._sub_storage = jIO.createJIO(spec.sub_storage, utils);
   }
 
   UUIDStorage.prototype.get = function () {

src/jio.storage/websqlstorage.js

@@ -69,7 +69,8 @@
       });
   }
 
-  function WebSQLStorage(spec) {
+  function WebSQLStorage(spec, utils) {
+    this._utils = utils;
     if (typeof spec.database !== 'string' || !spec.database) {
       throw new TypeError("database must be a string " +
                           "which contains more than one character.");

src/jio.storage/zipstorage.js

@@ -12,8 +12,9 @@
 
   var MIME_TYPE = "application/x-jio-utf16_lz_string";
 
-  function ZipStorage(spec) {
-    this._sub_storage = jIO.createJIO(spec.sub_storage);
+  function ZipStorage(spec, utils) {
+    this._utils = utils;
+    this._sub_storage = jIO.createJIO(spec.sub_storage, utils);
   }
 
   ZipStorage.prototype.get = function () {

src/queries/build/parser.js

@@ -90,13 +90,13 @@ case 5: case 8: case 11: case 14: case 16:
  this.$ = $$[$0]; 
 break;
 case 6:
- this.$ = mkComplexQuery('', 'AND', [$$[$0-1], $$[$0]]); 
+ this.$ = mkComplexQuery('AND', [$$[$0-1], $$[$0]]); 
 break;
 case 7:
- this.$ = mkComplexQuery('', 'OR', [$$[$0-2], $$[$0]]); 
+ this.$ = mkComplexQuery('OR', [$$[$0-2], $$[$0]]); 
 break;
 case 9:
- this.$ = mkComplexQuery('', 'AND', [$$[$0-2], $$[$0]]); 
+ this.$ = mkComplexQuery('AND', [$$[$0-2], $$[$0]]); 
 break;
 case 10:
  this.$ = mkNotQuery($$[$0]); 
@@ -105,7 +105,7 @@ case 12:
  this.$ = $$[$0-1]; 
 break;
 case 13:
- querySetKey($$[$0], $$[$0-2]); this.$ = $$[$0]; 
+ simpleQuerySetKey($$[$0], $$[$0-2]); this.$ = $$[$0]; 
 break;
 case 15:
  $$[$0].operator = $$[$0-1] ; this.$ = $$[$0]; 

src/queries/core/parser.par

@@ -45,13 +45,13 @@ end
 
 search_text
     : and_expression                { $$ = $1; }
-    | and_expression search_text    { $$ = mkComplexQuery('', 'AND', [$1, $2]); }
-    | and_expression OR search_text { $$ = mkComplexQuery('', 'OR', [$1, $3]); }
+    | and_expression search_text    { $$ = mkComplexQuery('AND', [$1, $2]); }
+    | and_expression OR search_text { $$ = mkComplexQuery('OR', [$1, $3]); }
     ;
 
 and_expression
     : boolean_expression                    { $$ = $1; }
-    | boolean_expression AND and_expression { $$ = mkComplexQuery('', 'AND', [$1, $3]); }
+    | boolean_expression AND and_expression { $$ = mkComplexQuery('AND', [$1, $3]); }
     ;
 
 boolean_expression
@@ -61,7 +61,7 @@ boolean_expression
 
 expression
     : LEFT_PARENTHESE search_text RIGHT_PARENTHESE { $$ = $2; }
-    | WORD DEFINITION expression                   { querySetKey($3, $1); $$ = $3; }
+    | WORD DEFINITION expression                   { simpleQuerySetKey($3, $1); $$ = $3; }
     | value                                        { $$ = $1; }
     ;
 

src/queries/parser-begin.js

@@ -26,9 +26,9 @@ var arrayExtend = function () {
   if (query.operator === "NOT") {
     return query.query_list[0];
   }
-  return {"type": "complex", "key": "", "operator": "NOT", "query_list": [query]};
+  return {"type": "complex", "operator": "NOT", "query_list": [query]};
 
-}, mkComplexQuery = function (key, operator, query_list) {
+}, mkComplexQuery = function (operator, query_list) {
   var i, query_list2 = [];
   for (i = 0; i < query_list.length; i += 1) {
     if (query_list[i].operator === operator) {
@@ -37,10 +37,17 @@ var arrayExtend = function () {
       query_list2.push(query_list[i]);
     }
   }
-  return {type:"complex",key:key,operator:operator,query_list:query_list2};
+  return {type:"complex",operator:operator,query_list:query_list2};
 
-}, querySetKey = function (query, key) {
-  if (({simple: 1, complex: 1})[query.type] && !query.key) {
+}, simpleQuerySetKey = function (query, key) {
+  var i;
+  if (query.type === "complex") {
+    for (i = 0; i < query.query_list.length; ++i) {
+      simpleQuerySetKey (query.query_list[i],key);
+    }
+    return true;
+  }
+  if (query.type === "simple" && !query.key) {
     query.key = key;
     return true;
   }

src/queries/query.js

@@ -519,8 +519,6 @@
      */
     this.operator = spec.operator;
 
-    this.key = spec.key || this.key;
-
     /**
      * The sub Query list which are used to query an item.
      *
@@ -540,7 +538,6 @@
 
   ComplexQuery.prototype.operator = "AND";
   ComplexQuery.prototype.type = "complex";
-  ComplexQuery.prototype.key = "";
 
   /**
    * #crossLink "Query/match:method"
@@ -557,8 +554,21 @@
    * #crossLink "Query/toString:method"
    */
   ComplexQuery.prototype.toString = function () {
-    /*global objectToSearchText */
-    return objectToSearchText(this.toJSON());
+    var str_list = [], this_operator = this.operator;
+    if (this.operator === "NOT") {
+      str_list.push("NOT (");
+      str_list.push(this.query_list[0].toString());
+      str_list.push(")");
+      return str_list.join(" ");
+    }
+    this.query_list.forEach(function (query) {
+      str_list.push("(");
+      str_list.push(query.toString());
+      str_list.push(")");
+      str_list.push(this_operator);
+    });
+    str_list.length -= 1;
+    return str_list.join(" ");
   };
 
   /**
@@ -568,7 +578,6 @@
     var s = {
       "type": "complex",
       "operator": this.operator,
-      "key": this.key,
       "query_list": []
     };
     this.query_list.forEach(function (query) {
@@ -658,26 +667,12 @@
   };
 
   function objectToSearchText(query) {
-    var str_list = [], operator = "", query_list = null;
+    var str_list = [];
     if (query.type === "complex") {
-      query_list = query.query_list || [];
-      if (query_list.length === 0) {
-        return "";
-      }
-      operator = query.operator;
-      if (operator === "NOT") {
-        str_list.push("NOT");
-        // fallback to AND operator if several queries are given
-        // i.e. `NOT ( a AND b )`
-        operator = "AND";
-      }
-      if (query.key) {
-        str_list.push(query.key + ":");
-      }
       str_list.push("(");
-      query_list.forEach(function (sub_query) {
+      (query.query_list || []).forEach(function (sub_query) {
         str_list.push(objectToSearchText(sub_query));
-        str_list.push(operator);
+        str_list.push(query.operator);
       });
       str_list.length -= 1;
       str_list.push(")");
@@ -854,7 +849,8 @@
    * #crossLink "Query/toString:method"
    */
   SimpleQuery.prototype.toString = function () {
-    return objectToSearchText(this.toJSON());
+    return (this.key ? this.key + ":" : "") +
+      (this.operator ? " " + this.operator : "") + ' "' + this.value + '"';
   };
 
   /**

test/jio.storage/davstorage.tests.js

@@ -11,7 +11,8 @@
     equal = QUnit.equal,
     module = QUnit.module,
     domain = "https://example.org",
-    basic_login = "login:passwd";
+    basic_login = "login:passwd",
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // davStorage constructor
@@ -30,6 +31,15 @@
     deepEqual(jio.__storage._with_credentials, undefined);
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "dav",
+      url: domain
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   test("Storage store basic login", function () {
     var jio = jIO.createJIO({
       type: "dav",

test/jio.storage/documentstorage.tests.js

@@ -9,7 +9,8 @@
     expect = QUnit.expect,
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
-    module = QUnit.module;
+    module = QUnit.module,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Custom test substorage definition
@@ -19,6 +20,13 @@
   }
   jIO.addStorage('documentstorage200', Storage200);
 
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('documentstoragecallback', Storagecallback);
+
   /////////////////////////////////////////////////////////////////
   // documentStorage.constructor
   /////////////////////////////////////////////////////////////////
@@ -38,6 +46,19 @@
 
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "document",
+      sub_storage: {
+        type: "documentstoragecallback"
+      }
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._sub_storage.__storage._utils.callback(), true);
+
+  });
+
   test("accept parameters", function () {
     var jio = jIO.createJIO({
       type: "document",

test/jio.storage/drivetojiomapping.tests.js

@@ -9,7 +9,8 @@
     expect = QUnit.expect,
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
-    module = QUnit.module;
+    module = QUnit.module,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Custom test substorage definition
@@ -19,6 +20,13 @@
   }
   jIO.addStorage('drivetojiomapping200', Storage200);
 
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('drivetojiomappingcallback', Storagecallback);
+
   /////////////////////////////////////////////////////////////////
   // driveToJioMapping.constructor
   /////////////////////////////////////////////////////////////////
@@ -36,6 +44,19 @@
 
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "drivetojiomapping",
+      sub_storage: {
+        type: "drivetojiomappingcallback"
+      }
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._sub_storage.__storage._utils.callback(), true);
+
+  });
+
   /////////////////////////////////////////////////////////////////
   // driveToJioMapping.get
   /////////////////////////////////////////////////////////////////

test/jio.storage/dropboxstorage.tests.js

@@ -10,7 +10,8 @@
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
     module = QUnit.module,
-    token = "sample_token";
+    token = "sample_token",
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // DropboxStorage constructor
@@ -26,6 +27,15 @@
     deepEqual(jio.__storage._access_token, token);
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "dropbox",
+      access_token: token
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   /////////////////////////////////////////////////////////////////
   // DropboxStorage.put
   /////////////////////////////////////////////////////////////////

test/jio.storage/erp5storage.tests.js

@@ -11,6 +11,7 @@
     equal = QUnit.equal,
     module = QUnit.module,
     domain = "https://example.org",
+    utils = {callback: function () {return true; }},
     traverse_template = domain + "?mode=traverse{&relative_url,view}",
     search_template = domain + "?mode=search{&query,select_list*,limit*," +
       "sort_on*,local_roles*,selection_domain*}",
@@ -50,6 +51,15 @@
     deepEqual(jio.__storage._default_view_reference, "bar_view");
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "erp5",
+      url: domain
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   /////////////////////////////////////////////////////////////////
   // erp5Storage.get
   /////////////////////////////////////////////////////////////////

test/jio.storage/fbstorage.tests.js

@@ -12,7 +12,8 @@
     module = QUnit.module,
     throws = QUnit.throws,
     token = "sample_token",
-    user_id = "sample_user_id";
+    user_id = "sample_user_id",
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Facebook Storage constructor
@@ -31,6 +32,16 @@
     deepEqual(jio.__storage._user_id, user_id);
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "facebook",
+      access_token: token,
+      user_id: user_id
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   test("reject non string token", function () {
 
     throws(

test/jio.storage/gdrivestorage.tests.js

@@ -12,6 +12,7 @@
     module = QUnit.module,
     throws = QUnit.throws,
     token = "sample_token",
+    utils = {callback: function () {return true; }},
     domain = "https://www.googleapis.com",
     boundary = "---------314159265358979323846",
     list_url = domain + "/drive/v2/files" +
@@ -58,6 +59,15 @@
     deepEqual(jio.__storage._access_token, token);
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "gdrive",
+      access_token: token
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   test("reject invalid trashing parameter", function () {
 
     throws(

test/jio.storage/httpstorage.tests.js

@@ -10,7 +10,8 @@
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
     module = QUnit.module,
-    domain = "https://example.org";
+    domain = "https://example.org",
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // davStorage constructor
@@ -27,6 +28,14 @@
     deepEqual(jio.__storage._timeout, 0);
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "http"
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   test("Storage store catch_error", function () {
     var jio = jIO.createJIO({
       type: "http",

test/jio.storage/indexeddbstorage.tests.js

@@ -13,6 +13,7 @@
     equal = QUnit.equal,
     module = QUnit.module,
     big_string = "",
+    utils = {callback: function () {return true; }},
     j;
 
   for (j = 0; j < 3000000; j += 1) {
@@ -48,6 +49,15 @@
     deepEqual(jio.__storage._database_name, "jio:qunit");
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "indexeddb",
+      database: "qunit"
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   /////////////////////////////////////////////////////////////////
   // documentStorage.hasCapacity
   /////////////////////////////////////////////////////////////////

test/jio.storage/localstorage.tests.js

@@ -11,7 +11,8 @@
     expect = QUnit.expect,
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
-    module = QUnit.module;
+    module = QUnit.module,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // localStorage.constructor
@@ -26,6 +27,14 @@
     equal(jio.__storage._storage, localStorage);
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "local"
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   test("sessiononly", function () {
     var jio = jIO.createJIO({
       type: "local",

test/jio.storage/memorystorage.tests.js

@@ -9,7 +9,8 @@
     expect = QUnit.expect,
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
-    module = QUnit.module;
+    module = QUnit.module,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // memoryStorage constructor
@@ -25,6 +26,14 @@
     deepEqual(jio.__storage._database, {});
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "memory"
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   test("Storage's memory database is not shared", function () {
     var jio = jIO.createJIO({
       "type": "memory"

test/jio.storage/parserstorage.tests.js

@@ -9,7 +9,8 @@
     expect = QUnit.expect,
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
-    module = QUnit.module;
+    module = QUnit.module,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Custom RSS test substorage definition
@@ -51,6 +52,18 @@
   };
 
   jIO.addStorage('rssstorage200', RSSStorage200);
+
+  /////////////////////////////////////////////////////////////////
+  // Custom callback test substorage definition
+  /////////////////////////////////////////////////////////////////
+
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('parsestoragecallback', Storagecallback);
+
   /////////////////////////////////////////////////////////////////
   // Custom atom test substorage definition
   /////////////////////////////////////////////////////////////////
@@ -174,6 +187,19 @@
     equal(jio.__storage._parser, undefined);
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "parser",
+      sub_storage: {
+        type: "parsestoragecallback"
+      }
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._sub_storage.__storage._utils.callback(), true);
+
+  });
+
   /////////////////////////////////////////////////////////////////
   // ParserStorage.allDocs
   /////////////////////////////////////////////////////////////////

test/jio.storage/qiniustorage.tests.js

@@ -18,7 +18,8 @@
       bucket: bucket,
       access_key: access_key,
       secret_key: secret_key
-    };
+    },
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // qiniuStorage constructor
@@ -34,6 +35,14 @@
     deepEqual(jio.__storage._secret_key, qiniu_spec.secret_key);
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "qiniu"
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+  });
+
   /////////////////////////////////////////////////////////////////
   // qiniuStorage.get
   /////////////////////////////////////////////////////////////////

test/jio.storage/querystorage.tests.js

@@ -10,7 +10,8 @@
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
     module = QUnit.module,
-    throws = QUnit.throws;
+    throws = QUnit.throws,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Custom test substorage definition
@@ -20,6 +21,13 @@
   }
   jIO.addStorage('querystorage200', Storage200);
 
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('querystoragecallback', Storagecallback);
+
   /////////////////////////////////////////////////////////////////
   // queryStorage.constructor
   /////////////////////////////////////////////////////////////////
@@ -45,6 +53,19 @@
 
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "query",
+      sub_storage: {
+        type: "querystoragecallback"
+      }
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._sub_storage.__storage._utils.callback(), true);
+
+  });
+
   test("failed on wrond schema", function () {
     throws(
       function () {

test/jio.storage/replicatestorage.tests.js

@@ -12,6 +12,7 @@
     module = QUnit.module,
     throws = QUnit.throws,
     big_string = "",
+    utils = {callback: function () {return true; }},
     j;
 
   for (j = 0; j < 30; j += 1) {
@@ -36,6 +37,27 @@
   }
   jIO.addStorage('signaturestorage2713', Storage2713);
 
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('localcallback', Storagecallback);
+
+  function Storagecallback1(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('replicatecallback', Storagecallback1);
+
+  function Storagecallback2(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('signaturecallback', Storagecallback2);
+
   /////////////////////////////////////////////////////////////////
   // replicateStorage.constructor
   /////////////////////////////////////////////////////////////////
@@ -103,6 +125,30 @@
 
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "replicate",
+      local_sub_storage: {
+        type: "localcallback"
+      },
+      remote_sub_storage: {
+        type: "replicatecallback"
+      },
+      signature_sub_storage: {
+        type: "signaturecallback"
+      }
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._local_sub_storage.__storage.
+      _utils.callback(), true);
+    deepEqual(jio.__storage._remote_sub_storage.__storage.
+      _utils.callback(), true);
+    deepEqual(jio.__storage._signature_sub_storage.__storage.
+      _utils.callback(), true);
+
+  });
+
   test("accept parameters", function () {
     var jio = jIO.createJIO({
       type: "replicate",

test/jio.storage/shastorage.tests.js

@@ -10,7 +10,8 @@
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
     module = QUnit.module,
-    throws = QUnit.throws;
+    throws = QUnit.throws,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Custom test substorage definition
@@ -20,6 +21,13 @@
   }
   jIO.addStorage('shastorage200', Storage200);
 
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('shastoragecallback', Storagecallback);
+
   /////////////////////////////////////////////////////////////////
   // shaStorage.constructor
   /////////////////////////////////////////////////////////////////
@@ -37,6 +45,19 @@
 
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "document",
+      sub_storage: {
+        type: "shastoragecallback"
+      }
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._sub_storage.__storage._utils.callback(), true);
+
+  });
+
   /////////////////////////////////////////////////////////////////
   // shaStorage.get
   /////////////////////////////////////////////////////////////////

test/jio.storage/unionstorage.tests.js

@@ -11,7 +11,8 @@
     equal = QUnit.equal,
     module = QUnit.module,
     throws = QUnit.throws,
-    frozen_blob = new Blob(["foobar"]);
+    frozen_blob = new Blob(["foobar"]),
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Custom test substorage definition
@@ -115,6 +116,13 @@
   Storage500.prototype.repair = generateError;
   jIO.addStorage('unionstorage500', Storage500);
 
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('unioncallback', Storagecallback);
+
   /////////////////////////////////////////////////////////////////
   // unionStorage.constructor
   /////////////////////////////////////////////////////////////////
@@ -145,6 +153,20 @@
     equal(jio.__storage._storage_list[1].__type, "unionstorage200");
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "union",
+      storage_list: [{
+        type: "unioncallback"
+      }]
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._storage_list["0"].
+      __storage._utils.callback(), true);
+
+  });
+
   /////////////////////////////////////////////////////////////////
   // unionStorage.get
   /////////////////////////////////////////////////////////////////

test/jio.storage/uuidstorage.tests.js

@@ -10,7 +10,8 @@
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
     module = QUnit.module,
-    throws = QUnit.throws;
+    throws = QUnit.throws,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Custom test substorage definition
@@ -20,6 +21,13 @@
   }
   jIO.addStorage('uuidstorage200', Storage200);
 
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('uuidcallback', Storagecallback);
+
   /////////////////////////////////////////////////////////////////
   // uuidStorage.constructor
   /////////////////////////////////////////////////////////////////
@@ -37,6 +45,19 @@
 
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "uuid",
+      sub_storage: {
+        type: "uuidcallback"
+      }
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._sub_storage.__storage._utils.callback(), true);
+
+  });
+
   /////////////////////////////////////////////////////////////////
   // uuidStorage.get
   /////////////////////////////////////////////////////////////////

test/jio.storage/zipstorage.tests.js

@@ -10,7 +10,8 @@
     deepEqual = QUnit.deepEqual,
     equal = QUnit.equal,
     throws = QUnit.throws,
-    module = QUnit.module;
+    module = QUnit.module,
+    utils = {callback: function () {return true; }};
 
   /////////////////////////////////////////////////////////////////
   // Custom test substorage definition
@@ -20,6 +21,13 @@
   }
   jIO.addStorage('zipstorage200', Storage200);
 
+  function Storagecallback(spec, utils) {
+    this._spec = spec;
+    this._utils = utils;
+    return this;
+  }
+  jIO.addStorage('zipstoragecallback', Storagecallback);
+
   /////////////////////////////////////////////////////////////////
   // ZipStorage.constructor
   /////////////////////////////////////////////////////////////////
@@ -33,6 +41,19 @@
     equal(jio.__storage._sub_storage.__type, "zipstorage200");
   });
 
+  test("Test callback", function () {
+    var jio = jIO.createJIO({
+      type: "document",
+      sub_storage: {
+        type: "zipstoragecallback"
+      }
+    }, utils);
+
+    deepEqual(jio.__storage._utils.callback(), true);
+    deepEqual(jio.__storage._sub_storage.__storage._utils.callback(), true);
+
+  });
+
   /////////////////////////////////////////////////////////////////
   // ZipStorage.get
   /////////////////////////////////////////////////////////////////

test/queries/tests.js

@@ -258,11 +258,9 @@
       {
         "type": "complex",
         "operator": "NOT",
-        "key": "",
         "query_list": [{
           "type": "complex",
           "operator": "OR",
-          "key": "",
           "query_list": [{
             "key": "a",
             "operator": "=",
@@ -271,7 +269,6 @@
           }, {
             "type": "complex",
             "operator": "AND",
-            "key": "",
             "query_list": [{
               "key": "c",
               "type": "simple",
@@ -311,23 +308,10 @@
           "NOT(a:=b OR c:% AND d:<2)"
         )
       ).toString(),
-      "NOT ( ( a: = \"b\" OR ( c:  \"%\" AND d: < \"2\" ) ) )",
+      "NOT ( ( a: = \"b\" ) OR ( ( c: \"%\" ) AND ( d: < \"2\" ) ) )",
       "create(create(\"NOT(a:=b OR c:% AND d:<2)\")).toString();"
     );
 
-    deepEqual(
-      jIO.QueryFactory.create(jIO.Query.objectToSearchText(jsoned)).toJSON(),
-      jsoned,
-      "create( objectToSearchText(create(\"NOT(a:=b OR c:% AND d:<2)\")" +
-        ".toJSON()) ).toJSON()"
-    );
-
-    deepEqual(
-      jIO.QueryFactory.create("a:(b OR c)").toString(),
-      "a: (  \"b\" OR  \"c\" )",
-      "create( \"a:(b OR c)\" ).toString()"
-    );
-
   });
 
   test('Docs with space, tab, and newline', function () {