complex queries module redesigned to moved methods

src/queries/complexquery.js

 /*jslint indent: 2, maxlen: 80, sloppy: true, nomen: true */
-/*global newClass: true, Query: true, query_class_dict: true,
+/*global Query: true, query_class_dict: true, inherits: true,
          _export: true, QueryFactory: true */
 
 /**
@@ -13,7 +13,8 @@
  * @param  {String} spec.key The metadata key
  * @param  {String} spec.value The value of the metadata to compare
  */
-var ComplexQuery = newClass(Query, function (spec) {
+function ComplexQuery(spec) {
+  Query.call(this);
 
   /**
    * Logical operator to use to compare object values
@@ -36,93 +37,96 @@ var ComplexQuery = newClass(Query, function (spec) {
   this.query_list = spec.query_list || [];
   this.query_list = this.query_list.map(QueryFactory.create);
 
-  /**
-   * #crossLink "Query/match:method"
-   */
-  this.match = function (item, wildcard_character) {
-    return this[this.operator](item, wildcard_character);
-  };
+}
+inherits(ComplexQuery, Query);
+ComplexQuery.prototype.constructor = ComplexQuery;
 
-  /**
-   * #crossLink "Query/toString:method"
-   */
-  this.toString = function () {
-    var str_list = ["("], this_operator = this.operator;
-    this.query_list.forEach(function (query) {
-      str_list.push(query.toString());
-      str_list.push(this_operator);
-    });
-    str_list.pop(); // remove last operator
-    str_list.push(")");
-    return str_list.join(" ");
-  };
+/**
+ * #crossLink "Query/match:method"
+ */
+ComplexQuery.prototype.match = function (item, wildcard_character) {
+  return this[this.operator](item, wildcard_character);
+};
 
-  /**
-   * #crossLink "Query/serialized:method"
-   */
-  this.serialized = function () {
-    var s = {
-      "type": "complex",
-      "operator": this.operator,
-      "query_list": []
-    };
-    this.query_list.forEach(function (query) {
-      s.query_list.push(query.serialized());
-    });
-    return s;
+/**
+ * #crossLink "Query/toString:method"
+ */
+ComplexQuery.prototype.toString = function () {
+  var str_list = ["("], this_operator = this.operator;
+  this.query_list.forEach(function (query) {
+    str_list.push(query.toString());
+    str_list.push(this_operator);
+  });
+  str_list.pop(); // remove last operator
+  str_list.push(")");
+  return str_list.join(" ");
+};
+
+/**
+ * #crossLink "Query/serialized:method"
+ */
+ComplexQuery.prototype.serialized = function () {
+  var s = {
+    "type": "complex",
+    "operator": this.operator,
+    "query_list": []
   };
+  this.query_list.forEach(function (query) {
+    s.query_list.push(query.serialized());
+  });
+  return s;
+};
 
-  /**
-   * Comparison operator, test if all sub queries match the
-   * item value
-   *
-   * @method AND
-   * @param  {Object} item The item to match
-   * @param  {String} wildcard_character The wildcard character
-   * @return {Boolean} true if all match, false otherwise
-   */
-  this.AND = function (item, wildcard_character) {
-    var i;
-    for (i = 0; i < this.query_list.length; i += 1) {
-      if (!this.query_list[i].match(item, wildcard_character)) {
-        return false;
-      }
+/**
+ * Comparison operator, test if all sub queries match the
+ * item value
+ *
+ * @method AND
+ * @param  {Object} item The item to match
+ * @param  {String} wildcard_character The wildcard character
+ * @return {Boolean} true if all match, false otherwise
+ */
+ComplexQuery.prototype.AND = function (item, wildcard_character) {
+  var i;
+  for (i = 0; i < this.query_list.length; i += 1) {
+    if (!this.query_list[i].match(item, wildcard_character)) {
+      return false;
     }
-    return true;
-  };
+  }
+  return true;
+};
 
-  /**
-   * Comparison operator, test if one of the sub queries matches the
-   * item value
-   *
-   * @method OR
-   * @param  {Object} item The item to match
-   * @param  {String} wildcard_character The wildcard character
-   * @return {Boolean} true if one match, false otherwise
-   */
-  this.OR =  function (item, wildcard_character) {
-    var i;
-    for (i = 0; i < this.query_list.length; i += 1) {
-      if (this.query_list[i].match(item, wildcard_character)) {
-        return true;
-      }
+/**
+ * Comparison operator, test if one of the sub queries matches the
+ * item value
+ *
+ * @method OR
+ * @param  {Object} item The item to match
+ * @param  {String} wildcard_character The wildcard character
+ * @return {Boolean} true if one match, false otherwise
+ */
+ComplexQuery.prototype.OR =  function (item, wildcard_character) {
+  var i;
+  for (i = 0; i < this.query_list.length; i += 1) {
+    if (this.query_list[i].match(item, wildcard_character)) {
+      return true;
     }
-    return false;
-  };
+  }
+  return false;
+};
 
-  /**
-   * Comparison operator, test if the sub query does not match the
-   * item value
-   *
-   * @method NOT
-   * @param  {Object} item The item to match
-   * @param  {String} wildcard_character The wildcard character
-   * @return {Boolean} true if one match, false otherwise
-   */
-  this.NOT = function (item, wildcard_character) {
-    return !this.query_list[0].match(item, wildcard_character);
-  };
-});
+/**
+ * Comparison operator, test if the sub query does not match the
+ * item value
+ *
+ * @method NOT
+ * @param  {Object} item The item to match
+ * @param  {String} wildcard_character The wildcard character
+ * @return {Boolean} true if one match, false otherwise
+ */
+ComplexQuery.prototype.NOT = function (item, wildcard_character) {
+  return !this.query_list[0].match(item, wildcard_character);
+};
 
 query_class_dict.complex = ComplexQuery;
 

src/queries/parser-begin.js

+/**
+ * Parse a text request to a json query object tree
+ *
+ * @param  {String} string The string to parse
+ * @return {Object} The json query tree
+ */
 function parseStringToObject(string) {

src/queries/parser-end.js

   return result;
 } // parseStringToObject
+
+_export('parseStringToObject', parseStringToObject);

src/queries/queryfactory.js

 /*jslint indent: 2, maxlen: 80, sloppy: true, nomen: true */
-/*global _export: true, ComplexQuery: true, SimpleQuery: true,
-         newClass: true, Query: true */
+/*global _export: true, ComplexQuery: true, SimpleQuery: true, Query: true,
+  parseStringToObject: true */
 
 
-var query_class_dict = {}, QueryFactory;
+var query_class_dict = {};
 
 /**
  * Provides static methods to create Query object
  *
  * @class QueryFactory
  */
-QueryFactory = newClass({
-  "static_methods": {
+function QueryFactory() {}
 
-    /**
-     * Creates Query object from a search text string or a serialized version
-     * of a Query.
-     *
-     * @method create
-     * @static
-     * @param  {Object,String} object The search text or the serialized version
-     *         of a Query
-     * @return {Query} A Query object
-     */
-    "create": function (object) {
-      if (object === "") {
-        return new Query();
-      }
-      if (typeof object === "string") {
-        object = Query.parseStringToObject(object);
-      }
-      if (typeof (object || {}).type === "string" &&
-          query_class_dict[object.type]) {
-        return new query_class_dict[object.type](object);
-      }
-      return null;
-    }
+/**
+ * Creates Query object from a search text string or a serialized version
+ * of a Query.
+ *
+ * @method create
+ * @static
+ * @param  {Object,String} object The search text or the serialized version
+ *         of a Query
+ * @return {Query} A Query object
+ */
+QueryFactory.create = function (object) {
+  if (object === "") {
+    return new Query();
+  }
+  if (typeof object === "string") {
+    object = parseStringToObject(object);
+  }
+  if (typeof (object || {}).type === "string" &&
+      query_class_dict[object.type]) {
+    return new query_class_dict[object.type](object);
   }
-}, function () {});
+  return null;
+};
 
 _export("QueryFactory", QueryFactory);

src/queries/simplequery.js

 /*jslint indent: 2, maxlen: 80, sloppy: true, nomen: true */
-/*global newClass: true, Query: true,
-         query_class_dict: true, _export: true */
+/*global Query: true, inherits: true, query_class_dict: true, _export: true,
+  convertStringToRegExp: true */
 
 /**
  * The SimpleQuery inherits from Query, and compares one metadata value
@@ -12,7 +12,9 @@
  * @param  {String} spec.key The metadata key
  * @param  {String} spec.value The value of the metadata to compare
  */
-var SimpleQuery = newClass(Query, function (spec) {
+function SimpleQuery(spec) {
+  Query.call(this);
+
   /**
    * Operator to use to compare object values
    *
@@ -39,118 +41,121 @@ var SimpleQuery = newClass(Query, function (spec) {
    */
   this.value = spec.value;
 
-  /**
-   * #crossLink "Query/match:method"
-   */
-  this.match = function (item, wildcard_character) {
-    return this[this.operator](item[this.key], this.value, wildcard_character);
-  };
+}
+inherits(SimpleQuery, Query);
+SimpleQuery.prototype.constructor = SimpleQuery;
 
-  /**
-   * #crossLink "Query/toString:method"
-   */
-  this.toString = function () {
-    return (this.key ? this.key + ": " : "") + (this.operator || "=") + ' "' +
-      this.value + '"';
-  };
+/**
+ * #crossLink "Query/match:method"
+ */
+SimpleQuery.prototype.match = function (item, wildcard_character) {
+  return this[this.operator](item[this.key], this.value, wildcard_character);
+};
 
-  /**
-   * #crossLink "Query/serialized:method"
-   */
-  this.serialized = function () {
-    return {
-      "type": "simple",
-      "operator": this.operator,
-      "key": this.key,
-      "value": this.value
-    };
-  };
+/**
+ * #crossLink "Query/toString:method"
+ */
+SimpleQuery.prototype.toString = function () {
+  return (this.key ? this.key + ": " : "") + (this.operator || "=") + ' "' +
+    this.value + '"';
+};
 
-  /**
-   * Comparison operator, test if this query value matches the item value
-   *
-   * @method =
-   * @param  {String} object_value The value to compare
-   * @param  {String} comparison_value The comparison value
-   * @param  {String} wildcard_character The wildcard_character
-   * @return {Boolean} true if match, false otherwise
-   */
-  this["="] = function (object_value, comparison_value,
-                        wildcard_character) {
-    return Query.convertStringToRegExp(
-      comparison_value.toString(),
-      wildcard_character || "%"
-    ).test(object_value.toString());
+/**
+ * #crossLink "Query/serialized:method"
+ */
+SimpleQuery.prototype.serialized = function () {
+  return {
+    "type": "simple",
+    "operator": this.operator,
+    "key": this.key,
+    "value": this.value
   };
+};
 
-  /**
-   * Comparison operator, test if this query value does not match the item value
-   *
-   * @method !=
-   * @param  {String} object_value The value to compare
-   * @param  {String} comparison_value The comparison value
-   * @param  {String} wildcard_character The wildcard_character
-   * @return {Boolean} true if not match, false otherwise
-   */
-  this["!="] = function (object_value, comparison_value,
-                         wildcard_character) {
-    return !Query.convertStringTextToRegExp(
-      comparison_value.toString(),
-      wildcard_character || "%"
-    ).test(object_value.toString());
-  };
+/**
+ * Comparison operator, test if this query value matches the item value
+ *
+ * @method =
+ * @param  {String} object_value The value to compare
+ * @param  {String} comparison_value The comparison value
+ * @param  {String} wildcard_character The wildcard_character
+ * @return {Boolean} true if match, false otherwise
+ */
+SimpleQuery.prototype["="] = function (object_value, comparison_value,
+                      wildcard_character) {
+  return convertStringToRegExp(
+    comparison_value.toString(),
+    wildcard_character || "%"
+  ).test(object_value.toString());
+};
 
-  /**
-   * Comparison operator, test if this query value is lower than the item value
-   *
-   * @method <
-   * @param  {Number, String} object_value The value to compare
-   * @param  {Number, String} comparison_value The comparison value
-   * @return {Boolean} true if lower, false otherwise
-   */
-  this["<"] = function (object_value, comparison_value) {
-    return object_value < comparison_value;
-  };
+/**
+ * Comparison operator, test if this query value does not match the item value
+ *
+ * @method !=
+ * @param  {String} object_value The value to compare
+ * @param  {String} comparison_value The comparison value
+ * @param  {String} wildcard_character The wildcard_character
+ * @return {Boolean} true if not match, false otherwise
+ */
+SimpleQuery.prototype["!="] = function (object_value, comparison_value,
+                       wildcard_character) {
+  return !convertStringToRegExp(
+    comparison_value.toString(),
+    wildcard_character || "%"
+  ).test(object_value.toString());
+};
 
-  /**
-   * Comparison operator, test if this query value is equal or lower than the
-   * item value
-   *
-   * @method <=
-   * @param  {Number, String} object_value The value to compare
-   * @param  {Number, String} comparison_value The comparison value
-   * @return {Boolean} true if equal or lower, false otherwise
-   */
-  this["<="] = function (object_value, comparison_value) {
-    return object_value <= comparison_value;
-  };
+/**
+ * Comparison operator, test if this query value is lower than the item value
+ *
+ * @method <
+ * @param  {Number, String} object_value The value to compare
+ * @param  {Number, String} comparison_value The comparison value
+ * @return {Boolean} true if lower, false otherwise
+ */
+SimpleQuery.prototype["<"] = function (object_value, comparison_value) {
+  return object_value < comparison_value;
+};
 
-  /**
-   * Comparison operator, test if this query value is greater than the item
-   * value
-   *
-   * @method >
-   * @param  {Number, String} object_value The value to compare
-   * @param  {Number, String} comparison_value The comparison value
-   * @return {Boolean} true if greater, false otherwise
-   */
-  this[">"] = function (object_value, comparison_value) {
-    return object_value > comparison_value;
-  };
+/**
+ * Comparison operator, test if this query value is equal or lower than the
+ * item value
+ *
+ * @method <=
+ * @param  {Number, String} object_value The value to compare
+ * @param  {Number, String} comparison_value The comparison value
+ * @return {Boolean} true if equal or lower, false otherwise
+ */
+SimpleQuery.prototype["<="] = function (object_value, comparison_value) {
+  return object_value <= comparison_value;
+};
 
-  /**
-   * Comparison operator, test if this query value is equal or greater than the
-   * item value
-   *
-   * @method >=
-   * @param  {Number, String} object_value The value to compare
-   * @param  {Number, String} comparison_value The comparison value
-   * @return {Boolean} true if equal or greater, false otherwise
-   */
-  this[">="] = function (object_value, comparison_value) {
-    return object_value >= comparison_value;
-  };
-});
+/**
+ * Comparison operator, test if this query value is greater than the item
+ * value
+ *
+ * @method >
+ * @param  {Number, String} object_value The value to compare
+ * @param  {Number, String} comparison_value The comparison value
+ * @return {Boolean} true if greater, false otherwise
+ */
+SimpleQuery.prototype[">"] = function (object_value, comparison_value) {
+  return object_value > comparison_value;
+};
+
+/**
+ * Comparison operator, test if this query value is equal or greater than the
+ * item value
+ *
+ * @method >=
+ * @param  {Number, String} object_value The value to compare
+ * @param  {Number, String} comparison_value The comparison value
+ * @return {Boolean} true if equal or greater, false otherwise
+ */
+SimpleQuery.prototype[">="] = function (object_value, comparison_value) {
+  return object_value >= comparison_value;
+};
 
 query_class_dict.simple = SimpleQuery;
 

src/queries/tool.js

 /*jslint indent: 2, maxlen: 80, sloppy: true, nomen: true */
 /*global _export: true */
 
-/**
- * Create a class, manage inheritance, static methods,
- * protected attributes and can hide methods or/and secure methods
- *
- * @param  {Class} Class Classes to inherit from (0..n). The last class
- *                       parameter will inherit from the previous one, and so on
- * @param  {Object} option Class option (0..n)
- * @param  {Boolean} [option.secure_methods=false] Make methods not configurable
- *                                                 and not writable
- * @param  {Boolean} [option.hide_methods=false] Make methods not enumerable
- * @param  {Boolean} [option.secure_static_methods=true] Make static methods not
- *                                                       configurable and not
- *                                                       writable
- * @param  {Boolean} [option.hide_static_methods=false] Make static methods not
- *                                                      enumerable
- * @param  {Object} [option.static_methods={}] Object of static methods
- * @param  {Function} constructor The new class constructor
- * @return {Class} The new class
- */
-function newClass() {
-  var j, k, constructors = [], option, new_class;
-
-  for (j = 0; j < arguments.length; j += 1) {
-    if (typeof arguments[j] === "function") {
-      constructors.push(arguments[j]);
-    } else if (typeof arguments[j] === "object") {
-      option = option || {};
-      for (k in arguments[j]) {
-        if (arguments[j].hasOwnProperty(k)) {
-          option[k] = arguments[j][k];
-        }
-      }
-    }
-  }
-
-  function postObjectCreation(that) {
-    // modify the object according to 'option'
-    var key;
-    if (option) {
-      for (key in that) {
-        if (that.hasOwnProperty(key)) {
-          if (typeof that[key] === "function") {
-            Object.defineProperty(that, key, {
-              "configurable": option.secure_methods ? false : true,
-              "enumerable": option.hide_methods ? false : true,
-              "writable": option.secure_methods ? false : true,
-              "value": that[key]
-            });
-          }
-        }
-      }
-    }
-  }
-
-  function postClassCreation(that) {
-    // modify the object according to 'option'
-    var key;
-    if (option) {
-      for (key in that) {
-        if (that.hasOwnProperty(key)) {
-          if (typeof that[key] === "function") {
-            Object.defineProperty(that, key, {
-              "configurable": option.secure_static_methods ===
-                false ? true : false,
-              "enumerable": option.hide_static_methods ? false : true,
-              "writable": option.secure_static_methods === false ? true : false,
-              "value": that[key]
-            });
-          }
-        }
-      }
-    }
-  }
-
-  new_class = function (spec, my) {
-    var i;
-    spec = spec || {};
-    my = my || {};
-    // don't use forEach !
-    for (i = 0; i < constructors.length; i += 1) {
-      constructors[i].apply(this, [spec, my]);
-    }
-    postObjectCreation(this);
-    return this;
-  };
-  option = option || {};
-  option.static_methods = option.static_methods || {};
-  for (j in option.static_methods) {
-    if (option.static_methods.hasOwnProperty(j)) {
-      new_class[j] = option.static_methods[j];
-    }
-  }
-  postClassCreation(new_class);
-  return new_class;
-}
-
 /**
  * Escapes regexp special chars from a string.
  *
@@ -156,3 +60,113 @@ function deepClone(object) {
   }
   return object;
 }
+
+/**
+ * Inherits the prototype methods from one constructor into another. The
+ * prototype of `constructor` will be set to a new object created from
+ * `superConstructor`.
+ */
+function inherits(constructor, superConstructor) {
+  constructor.super_ = superConstructor;
+  constructor.prototype = Object.create(superConstructor.prototype, {});
+}
+
+/**
+ * Does nothing
+ */
+function emptyFunction() {}
+
+/**
+ * Filter a list of items, modifying them to select only wanted keys. If
+ * `clone` is true, then the method will act on a cloned list.
+ *
+ * @param  {Array} select_option Key list to keep
+ * @param  {Array} list The item list to filter
+ * @param  {Boolean} [clone=false] If true, modifies a clone of the list
+ * @return {Array} The filtered list
+ */
+function select(select_option, list, clone) {
+  var i, j, new_item;
+  if (clone) {
+    list = deepClone(list);
+  }
+  for (i = 0; i < list.length; i += 1) {
+    new_item = {};
+    for (j = 0; j < select_option.length; j += 1) {
+      new_item[select_option[j]] = list[i][select_option[j]];
+    }
+    for (j in new_item) {
+      if (new_item.hasOwnProperty(j)) {
+        list[i] = new_item;
+        break;
+      }
+    }
+  }
+  return list;
+}
+
+_export('select', select);
+
+/**
+ * Sort a list of items, according to keys and directions. If `clone` is true,
+ * then the method will act on a cloned list.
+ *
+ * @param  {Array} sort_on_option List of couples [key, direction]
+ * @param  {Array} list The item list to sort
+ * @param  {Boolean} [clone=false] If true, modifies a clone of the list
+ * @return {Array} The filtered list
+ */
+function sortOn(sort_on_option, list, clone) {
+  var sort_index;
+  if (clone) {
+    list = deepClone(list);
+  }
+  for (sort_index = sort_on_option.length - 1; sort_index >= 0;
+       sort_index -= 1) {
+    list.sort(sortFunction(
+      sort_on_option[sort_index][0],
+      sort_on_option[sort_index][1]
+    ));
+  }
+  return list;
+}
+
+_export('sortOn', sortOn);
+
+/**
+ * Limit a list of items, according to index and length. If `clone` is true,
+ * then the method will act on a cloned list.
+ *
+ * @param  {Array} limit_option A couple [from, length]
+ * @param  {Array} list The item list to limit
+ * @param  {Boolean} [clone=false] If true, modifies a clone of the list
+ * @return {Array} The filtered list
+ */
+function limit(limit_option, list, clone) {
+  if (clone) {
+    list = deepClone(list);
+  }
+  list.splice(0, limit_option[0]);
+  if (limit_option[1]) {
+    list.splice(limit_option[1]);
+  }
+  return list;
+}
+
+_export('limit', limit);
+
+/**
+ * Convert a search text to a regexp.
+ *
+ * @param  {String} string The string to convert
+ * @param  {String} [wildcard_character=undefined] The wildcard chararter
+ * @return {RegExp} The search text regexp
+ */
+function convertStringToRegExp(string, wildcard_character) {
+  return new RegExp("^" + stringEscapeRegexpCharacters(string).replace(
+    stringEscapeRegexpCharacters(wildcard_character),
+    '.*'
+  ) + "$");
+}
+
+_export('convertStringToRegExp', convertStringToRegExp);