diff options
Diffstat (limited to 'lib/dojo/data/util')
-rw-r--r-- | lib/dojo/data/util/filter.js | 4 | ||||
-rw-r--r-- | lib/dojo/data/util/filter.js.uncompressed.js | 77 | ||||
-rw-r--r-- | lib/dojo/data/util/simpleFetch.js | 4 | ||||
-rw-r--r-- | lib/dojo/data/util/simpleFetch.js.uncompressed.js | 240 | ||||
-rw-r--r-- | lib/dojo/data/util/sorter.js | 4 | ||||
-rw-r--r-- | lib/dojo/data/util/sorter.js.uncompressed.js | 99 |
6 files changed, 422 insertions, 6 deletions
diff --git a/lib/dojo/data/util/filter.js b/lib/dojo/data/util/filter.js index 582b31131..d5d1f175e 100644 --- a/lib/dojo/data/util/filter.js +++ b/lib/dojo/data/util/filter.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, The Dojo Foundation All Rights Reserved. Available via Academic Free License >= 2.1 OR the modified BSD license. see: http://dojotoolkit.org/license for details */ //>>built -define("dojo/data/util/filter",["dojo/_base/lang"],function(_1){var _2=_1.getObject("dojo.data.util.filter",true);_2.patternToRegExp=function(_3,_4){var _5="^";var c=null;for(var i=0;i<_3.length;i++){c=_3.charAt(i);switch(c){case "\\":_5+=c;i++;_5+=_3.charAt(i);break;case "*":_5+=".*";break;case "?":_5+=".";break;case "$":case "^":case "/":case "+":case ".":case "|":case "(":case ")":case "{":case "}":case "[":case "]":_5+="\\";default:_5+=c;}}_5+="$";if(_4){return new RegExp(_5,"mi");}else{return new RegExp(_5,"m");}};return _2;});
\ No newline at end of file +define("dojo/data/util/filter",["../../_base/lang"],function(_1){var _2={};_1.setObject("dojo.data.util.filter",_2);_2.patternToRegExp=function(_3,_4){var _5="^";var c=null;for(var i=0;i<_3.length;i++){c=_3.charAt(i);switch(c){case "\\":_5+=c;i++;_5+=_3.charAt(i);break;case "*":_5+=".*";break;case "?":_5+=".";break;case "$":case "^":case "/":case "+":case ".":case "|":case "(":case ")":case "{":case "}":case "[":case "]":_5+="\\";default:_5+=c;}}_5+="$";if(_4){return new RegExp(_5,"mi");}else{return new RegExp(_5,"m");}};return _2;});
\ No newline at end of file diff --git a/lib/dojo/data/util/filter.js.uncompressed.js b/lib/dojo/data/util/filter.js.uncompressed.js new file mode 100644 index 000000000..ec3e99ff1 --- /dev/null +++ b/lib/dojo/data/util/filter.js.uncompressed.js @@ -0,0 +1,77 @@ +define("dojo/data/util/filter", ["../../_base/lang"], function(lang){ + // module: + // dojo/data/util/filter + // summary: + // TODOC + +var filter = {}; +lang.setObject("dojo.data.util.filter", filter); + +filter.patternToRegExp = function(/*String*/pattern, /*boolean?*/ ignoreCase){ + // summary: + // Helper function to convert a simple pattern to a regular expression for matching. + // description: + // Returns a regular expression object that conforms to the defined conversion rules. + // For example: + // + // - ca* -> /^ca.*$/ + // - *ca* -> /^.*ca.*$/ + // - *c\*a* -> /^.*c\*a.*$/ + // - *c\*a?* -> /^.*c\*a..*$/ + // + // and so on. + // pattern: string + // A simple matching pattern to convert that follows basic rules: + // + // - * Means match anything, so ca* means match anything starting with ca + // - ? Means match single character. So, b?b will match to bob and bab, and so on. + // - \ is an escape character. So for example, \* means do not treat * as a match, but literal character *. + // + // To use a \ as a character in the string, it must be escaped. So in the pattern it should be + // represented by \\ to be treated as an ordinary \ character instead of an escape. + // ignoreCase: + // An optional flag to indicate if the pattern matching should be treated as case-sensitive or not when comparing + // By default, it is assumed case sensitive. + + var rxp = "^"; + var c = null; + for(var i = 0; i < pattern.length; i++){ + c = pattern.charAt(i); + switch(c){ + case '\\': + rxp += c; + i++; + rxp += pattern.charAt(i); + break; + case '*': + rxp += ".*"; break; + case '?': + rxp += "."; break; + case '$': + case '^': + case '/': + case '+': + case '.': + case '|': + case '(': + case ')': + case '{': + case '}': + case '[': + case ']': + rxp += "\\"; //fallthrough + default: + rxp += c; + } + } + rxp += "$"; + if(ignoreCase){ + return new RegExp(rxp,"mi"); //RegExp + }else{ + return new RegExp(rxp,"m"); //RegExp + } + +}; + +return filter; +}); diff --git a/lib/dojo/data/util/simpleFetch.js b/lib/dojo/data/util/simpleFetch.js index d339ecda6..b4271f428 100644 --- a/lib/dojo/data/util/simpleFetch.js +++ b/lib/dojo/data/util/simpleFetch.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, The Dojo Foundation All Rights Reserved. Available via Academic Free License >= 2.1 OR the modified BSD license. see: http://dojotoolkit.org/license for details */ //>>built -define("dojo/data/util/simpleFetch",["dojo/_base/lang","dojo/_base/window","./sorter"],function(_1,_2,_3){var _4=_1.getObject("dojo.data.util.simpleFetch",true);_4.fetch=function(_5){_5=_5||{};if(!_5.store){_5.store=this;}var _6=this;var _7=function(_8,_9){if(_9.onError){var _a=_9.scope||_2.global;_9.onError.call(_a,_8,_9);}};var _b=function(_c,_d){var _e=_d.abort||null;var _f=false;var _10=_d.start?_d.start:0;var _11=(_d.count&&(_d.count!==Infinity))?(_10+_d.count):_c.length;_d.abort=function(){_f=true;if(_e){_e.call(_d);}};var _12=_d.scope||_2.global;if(!_d.store){_d.store=_6;}if(_d.onBegin){_d.onBegin.call(_12,_c.length,_d);}if(_d.sort){_c.sort(_3.createSortFunction(_d.sort,_6));}if(_d.onItem){for(var i=_10;(i<_c.length)&&(i<_11);++i){var _13=_c[i];if(!_f){_d.onItem.call(_12,_13,_d);}}}if(_d.onComplete&&!_f){var _14=null;if(!_d.onItem){_14=_c.slice(_10,_11);}_d.onComplete.call(_12,_14,_d);}};this._fetchItems(_5,_b,_7);return _5;};return _4;});
\ No newline at end of file +define("dojo/data/util/simpleFetch",["../../_base/lang","../../_base/kernel","./sorter"],function(_1,_2,_3){var _4={};_1.setObject("dojo.data.util.simpleFetch",_4);_4.errorHandler=function(_5,_6){if(_6.onError){var _7=_6.scope||_2.global;_6.onError.call(_7,_5,_6);}};_4.fetchHandler=function(_8,_9){var _a=_9.abort||null,_b=false,_c=_9.start?_9.start:0,_d=(_9.count&&(_9.count!==Infinity))?(_c+_9.count):_8.length;_9.abort=function(){_b=true;if(_a){_a.call(_9);}};var _e=_9.scope||_2.global;if(!_9.store){_9.store=this;}if(_9.onBegin){_9.onBegin.call(_e,_8.length,_9);}if(_9.sort){_8.sort(_3.createSortFunction(_9.sort,this));}if(_9.onItem){for(var i=_c;(i<_8.length)&&(i<_d);++i){var _f=_8[i];if(!_b){_9.onItem.call(_e,_f,_9);}}}if(_9.onComplete&&!_b){var _10=null;if(!_9.onItem){_10=_8.slice(_c,_d);}_9.onComplete.call(_e,_10,_9);}};_4.fetch=function(_11){_11=_11||{};if(!_11.store){_11.store=this;}this._fetchItems(_11,_1.hitch(this,"fetchHandler"),_1.hitch(this,"errorHandler"));return _11;};return _4;});
\ No newline at end of file diff --git a/lib/dojo/data/util/simpleFetch.js.uncompressed.js b/lib/dojo/data/util/simpleFetch.js.uncompressed.js new file mode 100644 index 000000000..94eb9e7a5 --- /dev/null +++ b/lib/dojo/data/util/simpleFetch.js.uncompressed.js @@ -0,0 +1,240 @@ +define("dojo/data/util/simpleFetch", ["../../_base/lang", "../../_base/kernel", "./sorter"], + function(lang, kernel, sorter){ + // module: + // dojo/data/util/simpleFetch + // summary: + // The simpleFetch mixin is designed to serve as a set of function(s) that can + // be mixed into other datastore implementations to accelerate their development. + +var simpleFetch = {}; +lang.setObject("dojo.data.util.simpleFetch", simpleFetch); + +simpleFetch.errorHandler = function(/*Object*/ errorData, /*Object*/ requestObject){ + // summary: + // The error handler when there is an error fetching items. This function should not be called + // directly and is used by simpleFetch.fetch(). + if(requestObject.onError){ + var scope = requestObject.scope || kernel.global; + requestObject.onError.call(scope, errorData, requestObject); + } +}; + +simpleFetch.fetchHandler = function(/*Array*/ items, /*Object*/ requestObject){ + // summary: + // The handler when items are sucessfully fetched. This function should not be called directly + // and is used by simpleFetch.fetch(). + var oldAbortFunction = requestObject.abort || null, + aborted = false, + + startIndex = requestObject.start?requestObject.start: 0, + endIndex = (requestObject.count && (requestObject.count !== Infinity))?(startIndex + requestObject.count):items.length; + + requestObject.abort = function(){ + aborted = true; + if(oldAbortFunction){ + oldAbortFunction.call(requestObject); + } + }; + + var scope = requestObject.scope || kernel.global; + if(!requestObject.store){ + requestObject.store = this; + } + if(requestObject.onBegin){ + requestObject.onBegin.call(scope, items.length, requestObject); + } + if(requestObject.sort){ + items.sort(sorter.createSortFunction(requestObject.sort, this)); + } + if(requestObject.onItem){ + for(var i = startIndex; (i < items.length) && (i < endIndex); ++i){ + var item = items[i]; + if(!aborted){ + requestObject.onItem.call(scope, item, requestObject); + } + } + } + if(requestObject.onComplete && !aborted){ + var subset = null; + if(!requestObject.onItem){ + subset = items.slice(startIndex, endIndex); + } + requestObject.onComplete.call(scope, subset, requestObject); + } +}; + +simpleFetch.fetch = function(/* Object? */ request){ + // summary: + // The simpleFetch mixin is designed to serve as a set of function(s) that can + // be mixed into other datastore implementations to accelerate their development. + // description: + // The simpleFetch mixin should work well for any datastore that can respond to a _fetchItems() + // call by returning an array of all the found items that matched the query. The simpleFetch mixin + // is not designed to work for datastores that respond to a fetch() call by incrementally + // loading items, or sequentially loading partial batches of the result + // set. For datastores that mixin simpleFetch, simpleFetch + // implements a fetch method that automatically handles eight of the fetch() + // arguments -- onBegin, onItem, onComplete, onError, start, count, sort and scope + // The class mixing in simpleFetch should not implement fetch(), + // but should instead implement a _fetchItems() method. The _fetchItems() + // method takes three arguments, the keywordArgs object that was passed + // to fetch(), a callback function to be called when the result array is + // available, and an error callback to be called if something goes wrong. + // The _fetchItems() method should ignore any keywordArgs parameters for + // start, count, onBegin, onItem, onComplete, onError, sort, and scope. + // The _fetchItems() method needs to correctly handle any other keywordArgs + // parameters, including the query parameter and any optional parameters + // (such as includeChildren). The _fetchItems() method should create an array of + // result items and pass it to the fetchHandler along with the original request object -- + // or, the _fetchItems() method may, if it wants to, create an new request object + // with other specifics about the request that are specific to the datastore and pass + // that as the request object to the handler. + // + // For more information on this specific function, see dojo/data/api/Read.fetch() + // + // request: + // The keywordArgs parameter may either be an instance of + // conforming to dojo/data/api/Request or may be a simple anonymous object + // that may contain any of the following: + // | { + // | query: query-object or query-string, + // | queryOptions: object, + // | onBegin: Function, + // | onItem: Function, + // | onComplete: Function, + // | onError: Function, + // | scope: object, + // | start: int + // | count: int + // | sort: array + // | } + // All implementations should accept keywordArgs objects with any of + // the 9 standard properties: query, onBegin, onItem, onComplete, onError + // scope, sort, start, and count. Some implementations may accept additional + // properties in the keywordArgs object as valid parameters, such as + // {includeOutliers:true}. + // + // ####The *query* parameter + // + // The query may be optional in some data store implementations. + // The dojo/data/api/Read API does not specify the syntax or semantics + // of the query itself -- each different data store implementation + // may have its own notion of what a query should look like. + // However, as of dojo 0.9, 1.0, and 1.1, all the provided datastores in dojo.data + // and dojox.data support an object structure query, where the object is a set of + // name/value parameters such as { attrFoo: valueBar, attrFoo1: valueBar1}. Most of the + // dijit widgets, such as ComboBox assume this to be the case when working with a datastore + // when they dynamically update the query. Therefore, for maximum compatibility with dijit + // widgets the recommended query parameter is a key/value object. That does not mean that the + // the datastore may not take alternative query forms, such as a simple string, a Date, a number, + // or a mix of such. Ultimately, The dojo/data/api/Read API is agnostic about what the query + // format. + // + // Further note: In general for query objects that accept strings as attribute + // value matches, the store should also support basic filtering capability, such as * + // (match any character) and ? (match single character). An example query that is a query object + // would be like: { attrFoo: "value*"}. Which generally means match all items where they have + // an attribute named attrFoo, with a value that starts with 'value'. + // + // ####The *queryOptions* parameter + // + // The queryOptions parameter is an optional parameter used to specify options that may modify + // the query in some fashion, such as doing a case insensitive search, or doing a deep search + // where all items in a hierarchical representation of data are scanned instead of just the root + // items. It currently defines two options that all datastores should attempt to honor if possible: + // | { + // | ignoreCase: boolean, // Whether or not the query should match case sensitively or not. Default behaviour is false. + // | deep: boolean // Whether or not a fetch should do a deep search of items and all child + // | // items instead of just root-level items in a datastore. Default is false. + // | } + // + // ####The *onBegin* parameter. + // + // function(size, request); + // If an onBegin callback function is provided, the callback function + // will be called just once, before the first onItem callback is called. + // The onBegin callback function will be passed two arguments, the + // the total number of items identified and the Request object. If the total number is + // unknown, then size will be -1. Note that size is not necessarily the size of the + // collection of items returned from the query, as the request may have specified to return only a + // subset of the total set of items through the use of the start and count parameters. + // + // ####The *onItem* parameter. + // + // function(item, request); + // + // If an onItem callback function is provided, the callback function + // will be called as each item in the result is received. The callback + // function will be passed two arguments: the item itself, and the + // Request object. + // + // ####The *onComplete* parameter. + // + // function(items, request); + // + // If an onComplete callback function is provided, the callback function + // will be called just once, after the last onItem callback is called. + // Note that if the onItem callback is not present, then onComplete will be passed + // an array containing all items which matched the query and the request object. + // If the onItem callback is present, then onComplete is called as: + // onComplete(null, request). + // + // ####The *onError* parameter. + // + // function(errorData, request); + // + // If an onError callback function is provided, the callback function + // will be called if there is any sort of error while attempting to + // execute the query. + // The onError callback function will be passed two arguments: + // an Error object and the Request object. + // + // ####The *scope* parameter. + // + // If a scope object is provided, all of the callback functions (onItem, + // onComplete, onError, etc) will be invoked in the context of the scope + // object. In the body of the callback function, the value of the "this" + // keyword will be the scope object. If no scope object is provided, + // the callback functions will be called in the context of dojo.global(). + // For example, onItem.call(scope, item, request) vs. + // onItem.call(dojo.global(), item, request) + // + // ####The *start* parameter. + // + // If a start parameter is specified, this is a indication to the datastore to + // only start returning items once the start number of items have been located and + // skipped. When this parameter is paired with 'count', the store should be able + // to page across queries with millions of hits by only returning subsets of the + // hits for each query + // + // ####The *count* parameter. + // + // If a count parameter is specified, this is a indication to the datastore to + // only return up to that many items. This allows a fetch call that may have + // millions of item matches to be paired down to something reasonable. + // + // ####The *sort* parameter. + // + // If a sort parameter is specified, this is a indication to the datastore to + // sort the items in some manner before returning the items. The array is an array of + // javascript objects that must conform to the following format to be applied to the + // fetching of items: + // | { + // | attribute: attribute || attribute-name-string, + // | descending: true|false; // Optional. Default is false. + // | } + // Note that when comparing attributes, if an item contains no value for the attribute + // (undefined), then it the default ascending sort logic should push it to the bottom + // of the list. In the descending order case, it such items should appear at the top of the list. + + request = request || {}; + if(!request.store){ + request.store = this; + } + + this._fetchItems(request, lang.hitch(this, "fetchHandler"), lang.hitch(this, "errorHandler")); + return request; // Object +}; + +return simpleFetch; +}); diff --git a/lib/dojo/data/util/sorter.js b/lib/dojo/data/util/sorter.js index 2591fe18e..9817434a3 100644 --- a/lib/dojo/data/util/sorter.js +++ b/lib/dojo/data/util/sorter.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, The Dojo Foundation All Rights Reserved. Available via Academic Free License >= 2.1 OR the modified BSD license. see: http://dojotoolkit.org/license for details */ //>>built -define("dojo/data/util/sorter",["dojo/_base/lang"],function(_1){var _2=_1.getObject("dojo.data.util.sorter",true);_2.basicComparator=function(a,b){var r=-1;if(a===null){a=undefined;}if(b===null){b=undefined;}if(a==b){r=0;}else{if(a>b||a==null){r=1;}}return r;};_2.createSortFunction=function(_3,_4){var _5=[];function _6(_7,_8,_9,s){return function(_a,_b){var a=s.getValue(_a,_7);var b=s.getValue(_b,_7);return _8*_9(a,b);};};var _c;var _d=_4.comparatorMap;var bc=_2.basicComparator;for(var i=0;i<_3.length;i++){_c=_3[i];var _e=_c.attribute;if(_e){var _f=(_c.descending)?-1:1;var _10=bc;if(_d){if(typeof _e!=="string"&&("toString" in _e)){_e=_e.toString();}_10=_d[_e]||bc;}_5.push(_6(_e,_f,_10,_4));}}return function(_11,_12){var i=0;while(i<_5.length){var ret=_5[i++](_11,_12);if(ret!==0){return ret;}}return 0;};};return _2;});
\ No newline at end of file +define("dojo/data/util/sorter",["../../_base/lang"],function(_1){var _2={};_1.setObject("dojo.data.util.sorter",_2);_2.basicComparator=function(a,b){var r=-1;if(a===null){a=undefined;}if(b===null){b=undefined;}if(a==b){r=0;}else{if(a>b||a==null){r=1;}}return r;};_2.createSortFunction=function(_3,_4){var _5=[];function _6(_7,_8,_9,s){return function(_a,_b){var a=s.getValue(_a,_7);var b=s.getValue(_b,_7);return _8*_9(a,b);};};var _c;var _d=_4.comparatorMap;var bc=_2.basicComparator;for(var i=0;i<_3.length;i++){_c=_3[i];var _e=_c.attribute;if(_e){var _f=(_c.descending)?-1:1;var _10=bc;if(_d){if(typeof _e!=="string"&&("toString" in _e)){_e=_e.toString();}_10=_d[_e]||bc;}_5.push(_6(_e,_f,_10,_4));}}return function(_11,_12){var i=0;while(i<_5.length){var ret=_5[i++](_11,_12);if(ret!==0){return ret;}}return 0;};};return _2;});
\ No newline at end of file diff --git a/lib/dojo/data/util/sorter.js.uncompressed.js b/lib/dojo/data/util/sorter.js.uncompressed.js new file mode 100644 index 000000000..268fa5847 --- /dev/null +++ b/lib/dojo/data/util/sorter.js.uncompressed.js @@ -0,0 +1,99 @@ +define("dojo/data/util/sorter", ["../../_base/lang"], function(lang){ + // module: + // dojo/data/util/sorter + // summary: + // TODOC + +var sorter = {}; +lang.setObject("dojo.data.util.sorter", sorter); + +sorter.basicComparator = function( /*anything*/ a, + /*anything*/ b){ + // summary: + // Basic comparison function that compares if an item is greater or less than another item + // description: + // returns 1 if a > b, -1 if a < b, 0 if equal. + // 'null' values (null, undefined) are treated as larger values so that they're pushed to the end of the list. + // And compared to each other, null is equivalent to undefined. + + //null is a problematic compare, so if null, we set to undefined. + //Makes the check logic simple, compact, and consistent + //And (null == undefined) === true, so the check later against null + //works for undefined and is less bytes. + var r = -1; + if(a === null){ + a = undefined; + } + if(b === null){ + b = undefined; + } + if(a == b){ + r = 0; + }else if(a > b || a == null){ + r = 1; + } + return r; //int {-1,0,1} +}; + +sorter.createSortFunction = function( /* attributes[] */sortSpec, /*dojo/data/api/Read*/ store){ + // summary: + // Helper function to generate the sorting function based off the list of sort attributes. + // description: + // The sort function creation will look for a property on the store called 'comparatorMap'. If it exists + // it will look in the mapping for comparisons function for the attributes. If one is found, it will + // use it instead of the basic comparator, which is typically used for strings, ints, booleans, and dates. + // Returns the sorting function for this particular list of attributes and sorting directions. + // sortSpec: + // A JS object that array that defines out what attribute names to sort on and whether it should be descenting or asending. + // The objects should be formatted as follows: + // | { + // | attribute: "attributeName-string" || attribute, + // | descending: true|false; // Default is false. + // | } + // store: + // The datastore object to look up item values from. + + var sortFunctions=[]; + + function createSortFunction(attr, dir, comp, s){ + //Passing in comp and s (comparator and store), makes this + //function much faster. + return function(itemA, itemB){ + var a = s.getValue(itemA, attr); + var b = s.getValue(itemB, attr); + return dir * comp(a,b); //int + }; + } + var sortAttribute; + var map = store.comparatorMap; + var bc = sorter.basicComparator; + for(var i = 0; i < sortSpec.length; i++){ + sortAttribute = sortSpec[i]; + var attr = sortAttribute.attribute; + if(attr){ + var dir = (sortAttribute.descending) ? -1 : 1; + var comp = bc; + if(map){ + if(typeof attr !== "string" && ("toString" in attr)){ + attr = attr.toString(); + } + comp = map[attr] || bc; + } + sortFunctions.push(createSortFunction(attr, + dir, comp, store)); + } + } + return function(rowA, rowB){ + var i=0; + while(i < sortFunctions.length){ + var ret = sortFunctions[i++](rowA, rowB); + if(ret !== 0){ + return ret;//int + } + } + return 0; //int + }; // Function +}; + +return sorter; +}); |