major change to cryptostorage and all storages now support callbacks

src/jio.js

@@ -209,64 +209,47 @@
     }
   }
 
-  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 function are not asynchronous
-      if (precondition_function !== undefined) {
-        precondition_result = precondition_function.apply(
-          context.__storage,
-          [argument_list, context, name]
-        );
-      }
+        precondition_result;
 
-      storage_method = context.__storage[name];
-      if (storage_method === undefined) {
-        throw new jIO.util.jIOError(
-          "Capacity '" + name + "' is not implemented on '" +
-            context.__type + "'",
-          501
-        );
-      }
-      queue = ensurePushableQueue(storage_method, argument_list,
-                                  context.__storage);
-
-      if (post_function !== undefined) {
-        queue
-          .push(function (result) {
+      return new RSVP.Queue()
+        .push(function () {
+          if (precondition_function !== undefined) {
+            return precondition_function.apply(
+              context.__storage,
+              [argument_list, context, 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 '" +
+                context.__type + "'",
+              501
+            );
+          }
+          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,16 +281,17 @@
   JioProxyStorage.prototype.post = function () {
     var context = this,
       argument_list = arguments;
-    return ensurePushableQueue(function () {
-      var storage_method = context.__storage.post;
-      if (storage_method === undefined) {
-        throw new jIO.util.jIOError(
-          "Capacity 'post' is not implemented on '" + context.__type + "'",
-          501
-        );
-      }
-      return context.__storage.post.apply(context.__storage, argument_list);
-    });
+    return new RSVP.Queue()
+      .push(function () {
+        var storage_method = context.__storage.post;
+        if (storage_method === undefined) {
+          throw new jIO.util.jIOError(
+            "Capacity 'post' is not implemented on '" + context.__type + "'",
+            501
+          );
+        }
+        return context.__storage.post.apply(context.__storage, argument_list);
+      });
   };
 
   declareMethod(JioProxyStorage, 'putAttachment', function (argument_list,
@@ -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,26 +439,27 @@
     if (options === undefined) {
       options = {};
     }
-    return ensurePushableQueue(function () {
-      if (context.hasCapacity("list") &&
-          ((options.query === undefined) || context.hasCapacity("query")) &&
-          ((options.sort_on === undefined) || context.hasCapacity("sort")) &&
-          ((options.select_list === undefined) ||
-           context.hasCapacity("select")) &&
-          ((options.include_docs === undefined) ||
-           context.hasCapacity("include")) &&
-          ((options.limit === undefined) || context.hasCapacity("limit"))) {
-        return context.buildQuery(options)
-          .push(function (result) {
-            return {
-              data: {
-                rows: result,
-                total_rows: result.length
-              }
-            };
-          });
-      }
-    });
+    return new RSVP.Queue()
+      .push(function () {
+        if (context.hasCapacity("list") &&
+            ((options.query === undefined) || context.hasCapacity("query")) &&
+            ((options.sort_on === undefined) || context.hasCapacity("sort")) &&
+            ((options.select_list === undefined) ||
+             context.hasCapacity("select")) &&
+            ((options.include_docs === undefined) ||
+             context.hasCapacity("include")) &&
+            ((options.limit === undefined) || context.hasCapacity("limit"))) {
+          return context.buildQuery(options);
+        }
+      })
+      .push(function (result) {
+        return {
+          data: {
+            rows: result,
+            total_rows: result.length
+          }
+        };
+      });
   };
 
   declareMethod(JioProxyStorage, "allAttachments", checkId);
@@ -478,13 +468,14 @@
   JioProxyStorage.prototype.repair = function () {
     var context = this,
       argument_list = arguments;
-    return ensurePushableQueue(function () {
-      var storage_method = context.__storage.repair;
-      if (storage_method !== undefined) {
-        return context.__storage.repair.apply(context.__storage,
-                                              argument_list);
-      }
-    });
+    return new RSVP.Queue()
+      .push(function () {
+        var storage_method = context.__storage.repair;
+        if (storage_method !== undefined) {
+          return context.__storage.repair.apply(context.__storage,
+                                                argument_list);
+        }
+      });
   };
 
   /////////////////////////////////////////////////////////////////

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;
   }
 
@@ -325,4 +326,4 @@
 
   jIO.addStorage('dropbox', DropboxStorage);
 
-}(jIO, RSVP, Blob, JSON));
+}(jIO, RSVP, Blob, JSON));
\ No newline at end of file

src/jio.storage/erp5storage.js

@@ -73,56 +73,59 @@
   };
 
   function extractPropertyFromFormJSON(json) {
-    var form = json._embedded._view,
-      converted_json = {
-        portal_type: json._links.type.name
-      },
-      form_data_json = {},
-      field,
-      key,
-      prefix_length,
-      result;
-
-    if (json._links.hasOwnProperty('parent')) {
-      converted_json.parent_relative_url =
-        new URI(json._links.parent.href).segment(2);
-    }
+    return new RSVP.Queue()
+      .push(function () {
+        var form = json._embedded._view,
+          converted_json = {
+            portal_type: json._links.type.name
+          },
+          form_data_json = {},
+          field,
+          key,
+          prefix_length,
+          result;
 
-    form_data_json.form_id = {
-      "key": [form.form_id.key],
-      "default": form.form_id["default"]
-    };
-    // XXX How to store datetime
-    for (key in form) {
-      if (form.hasOwnProperty(key)) {
-        field = form[key];
-        prefix_length = 0;
-        if (key.indexOf('my_') === 0 && field.editable) {
-          prefix_length = 3;
-        }
-        if (key.indexOf('your_') === 0) {
-          prefix_length = 5;
+        if (json._links.hasOwnProperty('parent')) {
+          converted_json.parent_relative_url =
+            new URI(json._links.parent.href).segment(2);
         }
-        if ((prefix_length !== 0) &&
-            (allowed_field_dict.hasOwnProperty(field.type))) {
-          form_data_json[key.substring(prefix_length)] = {
-            "default": field["default"],
-            "key": field.key
-          };
-          converted_json[key.substring(prefix_length)] = field["default"];
+
+        form_data_json.form_id = {
+          "key": [form.form_id.key],
+          "default": form.form_id["default"]
+        };
+        // XXX How to store datetime
+        for (key in form) {
+          if (form.hasOwnProperty(key)) {
+            field = form[key];
+            prefix_length = 0;
+            if (key.indexOf('my_') === 0 && field.editable) {
+              prefix_length = 3;
+            }
+            if (key.indexOf('your_') === 0) {
+              prefix_length = 5;
+            }
+            if ((prefix_length !== 0) &&
+                (allowed_field_dict.hasOwnProperty(field.type))) {
+              form_data_json[key.substring(prefix_length)] = {
+                "default": field["default"],
+                "key": field.key
+              };
+              converted_json[key.substring(prefix_length)] = field["default"];
+            }
+          }
         }
-      }
-    }
 
-    result = {
-      data: converted_json,
-      form_data: form_data_json
-    };
-    if (form.hasOwnProperty('_actions') &&
-        form._actions.hasOwnProperty('put')) {
-      result.action_href = form._actions.put.href;
-    }
-    return result;
+        result = {
+          data: converted_json,
+          form_data: form_data_json
+        };
+        if (form.hasOwnProperty('_actions') &&
+            form._actions.hasOwnProperty('put')) {
+          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 () {