From 870334be3f58507c05bfc72f3edbe5db10af4caf Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Tue, 2 Apr 2013 20:06:16 +0400 Subject: remove dojo uncompressed files --- lib/dojo/data/util/filter.js.uncompressed.js | 77 ------- lib/dojo/data/util/simpleFetch.js.uncompressed.js | 240 ---------------------- lib/dojo/data/util/sorter.js.uncompressed.js | 99 --------- 3 files changed, 416 deletions(-) delete mode 100644 lib/dojo/data/util/filter.js.uncompressed.js delete mode 100644 lib/dojo/data/util/simpleFetch.js.uncompressed.js delete mode 100644 lib/dojo/data/util/sorter.js.uncompressed.js (limited to 'lib/dojo/data/util') diff --git a/lib/dojo/data/util/filter.js.uncompressed.js b/lib/dojo/data/util/filter.js.uncompressed.js deleted file mode 100644 index ec3e99ff1..000000000 --- a/lib/dojo/data/util/filter.js.uncompressed.js +++ /dev/null @@ -1,77 +0,0 @@ -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.uncompressed.js b/lib/dojo/data/util/simpleFetch.js.uncompressed.js deleted file mode 100644 index 94eb9e7a5..000000000 --- a/lib/dojo/data/util/simpleFetch.js.uncompressed.js +++ /dev/null @@ -1,240 +0,0 @@ -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.uncompressed.js b/lib/dojo/data/util/sorter.js.uncompressed.js deleted file mode 100644 index 268fa5847..000000000 --- a/lib/dojo/data/util/sorter.js.uncompressed.js +++ /dev/null @@ -1,99 +0,0 @@ -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; -}); -- cgit v1.2.3