← Back to branch summary

~ahasenack/lazr-js/lazr-js-11.03-packaging

« back to all changes in this revision

Viewing changes to src-js/lazrjs/yui/collection/array-extras.js

  • Committer: Sidnei da Silva
  • Date: 2010-04-08 14:44:59 UTC
  • mfrom: (166.8.13 yui-3.1.0)
  • Revision ID: sidnei.da.silva@canonical.com-20100408144459-qozybvnrgr7iee7k
Merged yui-3.1.0 [r=therve,rockstar] [f=558457].

Updates lazr-js to use YUI 3.1.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src-js/lazrjs/yui/collection/array-extras.js
 
1
/*
 
2
Copyright (c) 2010, Yahoo! Inc. All rights reserved.
 
3
Code licensed under the BSD License:
 
4
http://developer.yahoo.com/yui/license.html
 
5
version: 3.1.0
 
6
build: 2026
 
7
*/
 
8
YUI.add('array-extras', function(Y) {
 
9
 
 
10
/**
 
11
 * Collection utilities beyond what is provided in the YUI core
 
12
 * @module collection
 
13
 * @submodule array-extras
 
14
 */
 
15
 
 
16
var L = Y.Lang, Native = Array.prototype, A = Y.Array;
 
17
 
 
18
/**
 
19
 * Adds the following array utilities to the YUI instance
 
20
 * (Y.Array).  This is in addition to the methods provided
 
21
 * in the core.
 
22
 * @class YUI~array~extras
 
23
 */
 
24
 
 
25
/**
 
26
 * Returns the index of the last item in the array
 
27
 * that contains the specified value, -1 if the
 
28
 * value isn't found.
 
29
 * @method Array.lastIndexOf
 
30
 * @static
 
31
 * @param a {Array} the array to search
 
32
 * @param val the value to search for
 
33
 * @return {int} the index of hte item that contains the value or -1
 
34
 */
 
35
A.lastIndexOf = (Native.lastIndexOf) ?
 
36
    function(a ,val) {
 
37
        return a.lastIndexOf(val);    
 
38
    } :
 
39
    function(a, val) {
 
40
        for (var i=a.length-1; i>=0; i=i-1) {
 
41
            if (a[i] === val) {
 
42
                break;
 
43
            }
 
44
        }
 
45
        return i;
 
46
    };
 
47
 
 
48
/**
 
49
 * Returns a copy of the array with the duplicate entries removed
 
50
 * @method Array.unique
 
51
 * @static
 
52
 * @param a {Array} the array to find the subset of uniques for
 
53
 * @param sort {bool} flag to denote if the array is sorted or not. Defaults to false, the more general operation
 
54
 * @return {Array} a copy of the array with duplicate entries removed
 
55
 */
 
56
A.unique = function(a, sort) {
 
57
    var b = a.slice(), i = 0, n = -1, item = null;
 
58
 
 
59
    while (i < b.length) {
 
60
        item = b[i];
 
61
        while ((n = A.lastIndexOf(b, item)) !== i) {
 
62
            b.splice(n, 1);
 
63
        }
 
64
        i += 1;
 
65
    }
 
66
 
 
67
    // Note: the sort option doesn't really belong here... I think it was added
 
68
    // because there was a way to fast path the two operations together.  That
 
69
    // implementation was not working, so I replaced it with the following.
 
70
    // Leaving it in so that the API doesn't get broken.
 
71
    if (sort) {
 
72
        if (L.isNumber(b[0])) {
 
73
            b.sort(A.numericSort);
 
74
        } else {
 
75
            b.sort();
 
76
        }
 
77
    }
 
78
 
 
79
    return b;
 
80
};
 
81
 
 
82
/**
 
83
* Executes the supplied function on each item in the array.
 
84
* Returns a new array containing the items that the supplied
 
85
* function returned true for.
 
86
* @method Array.filter
 
87
* @param a {Array} the array to iterate
 
88
* @param f {Function} the function to execute on each item
 
89
* @param o Optional context object
 
90
* @static
 
91
* @return {Array} The items on which the supplied function
 
92
* returned true. If no items matched an empty array is 
 
93
* returned.
 
94
*/
 
95
A.filter = (Native.filter) ?
 
96
    function(a, f, o) {
 
97
        return Native.filter.call(a, f, o);
 
98
    } :
 
99
    function(a, f, o) {
 
100
        var results = [];
 
101
        A.each(a, function(item, i, a) {
 
102
            if (f.call(o, item, i, a)) {
 
103
                results.push(item);
 
104
            }
 
105
        });
 
106
 
 
107
        return results;
 
108
    };
 
109
 
 
110
/**
 
111
* The inverse of filter. Executes the supplied function on each item. 
 
112
* Returns a new array containing the items that the supplied
 
113
* function returned *false* for.
 
114
* @method Array.reject
 
115
* @param a {Array} the array to iterate
 
116
* @param f {Function} the function to execute on each item
 
117
* @param o Optional context object
 
118
* @static
 
119
* @return {Array} The items on which the supplied function
 
120
* returned false.
 
121
*/
 
122
A.reject = function(a, f, o) {
 
123
    return A.filter(a, function(item, i, a) {
 
124
        return !f.call(o, item, i, a);
 
125
    });
 
126
};
 
127
 
 
128
/**
 
129
* Executes the supplied function on each item in the array.
 
130
* @method Array.every
 
131
* @param a {Array} the array to iterate
 
132
* @param f {Function} the function to execute on each item
 
133
* @param o Optional context object
 
134
* @static
 
135
* @return {boolean} true if every item in the array returns true
 
136
* from the supplied function.
 
137
*/
 
138
A.every = (Native.every) ?
 
139
    function(a, f, o) {
 
140
        return Native.every.call(a,f,o);
 
141
    } :
 
142
    function(a, f, o) {
 
143
        for (var i = 0, l = a.length; i < l; i=i+1) {
 
144
            if (!f.call(o, a[i], i, a)) {
 
145
                return false;
 
146
            }
 
147
        }
 
148
 
 
149
        return true;
 
150
    };
 
151
 
 
152
/**
 
153
* Executes the supplied function on each item in the array.
 
154
* @method Array.map
 
155
* @param a {Array} the array to iterate
 
156
* @param f {Function} the function to execute on each item
 
157
* @param o Optional context object
 
158
* @static
 
159
* @return {Array} A new array containing the return value
 
160
* of the supplied function for each item in the original
 
161
* array.
 
162
*/
 
163
A.map = (Native.map) ? 
 
164
    function(a, f, o) {
 
165
        return Native.map.call(a, f, o);
 
166
    } :
 
167
    function(a, f, o) {
 
168
        var results = [];
 
169
        A.each(a, function(item, i, a) {
 
170
            results.push(f.call(o, item, i, a));
 
171
        });
 
172
        return results;
 
173
    };
 
174
 
 
175
 
 
176
/**
 
177
* Executes the supplied function on each item in the array.
 
178
* Reduce "folds" the array into a single value.
 
179
* @method Array.reduce
 
180
* @param a {Array} the array to iterate
 
181
* @param init The initial value to start from
 
182
* @param f {Function} the function to execute on each item. It
 
183
* is responsible for returning the updated value of the
 
184
* computation.
 
185
* @param o Optional context object
 
186
* @static
 
187
* @return A value that results from iteratively applying the
 
188
* supplied function to each element in the array.
 
189
*/
 
190
A.reduce = (Native.reduce) ?
 
191
    function(a, init, f, o) {
 
192
        //Firefox's Array.reduce does not allow inclusion of a
 
193
        //  thisObject, so we need to implement it manually
 
194
        return Native.reduce.call(a, function(init, item, i, a) {
 
195
            return f.call(o, init, item, i, a);
 
196
        }, init);
 
197
    } :
 
198
    function(a, init, f, o) {
 
199
        var r = init;
 
200
        A.each(a, function (item, i, a) {
 
201
            r = f.call(o, r, item, i, a);
 
202
        });
 
203
        return r;
 
204
    };
 
205
 
 
206
 
 
207
/**
 
208
* Executes the supplied function on each item in the array,
 
209
* searching for the first item that matches the supplied
 
210
* function.
 
211
* @method Array.find
 
212
* @param a {Array} the array to search
 
213
* @param f {Function} the function to execute on each item. 
 
214
* Iteration is stopped as soon as this function returns true
 
215
* on an item.
 
216
* @param o Optional context object
 
217
* @static
 
218
* @return {object} the first item that the supplied function
 
219
* returns true for, or null if it never returns true
 
220
*/
 
221
A.find = function(a, f, o) {
 
222
    for(var i=0, l = a.length; i < l; i++) {
 
223
        if (f.call(o, a[i], i, a)) {
 
224
            return a[i];
 
225
        }
 
226
    }
 
227
    return null;
 
228
};
 
229
 
 
230
/**
 
231
* Iterates over an array, returning a new array of all the elements
 
232
* that match the supplied regular expression
 
233
* @method Array.grep
 
234
* @param a {Array} a collection to iterate over
 
235
* @param pattern {RegExp} The regular expression to test against 
 
236
* each item
 
237
* @static
 
238
* @return {Array} All the items in the collection that 
 
239
* produce a match against the supplied regular expression. 
 
240
* If no items match, an empty array is returned.
 
241
*/
 
242
A.grep = function (a, pattern) {
 
243
    return A.filter(a, function (item, index) {
 
244
        return pattern.test(item);
 
245
    });
 
246
};
 
247
 
 
248
 
 
249
/**
 
250
* Partitions an array into two new arrays, one with the items
 
251
* that match the supplied function, and one with the items that
 
252
* do not.
 
253
* @method Array.partition
 
254
* @param a {Array} a collection to iterate over
 
255
* @paran f {Function} a function that will receive each item 
 
256
* in the collection and its index.
 
257
* @param o Optional execution context of f.
 
258
* @static
 
259
* @return An object with two members, 'matches' and 'rejects',
 
260
* that are arrays containing the items that were selected or 
 
261
* rejected by the test function (or an empty array).
 
262
*/
 
263
A.partition = function (a, f, o) {
 
264
    var results = {
 
265
        matches: [], 
 
266
        rejects: []
 
267
    };
 
268
 
 
269
    A.each(a, function (item, index) {
 
270
        var set = f.call(o, item, index, a) ? results.matches : results.rejects;
 
271
        set.push(item);
 
272
    });
 
273
 
 
274
    return results;
 
275
};
 
276
 
 
277
/**
 
278
* Creates an array of arrays by pairing the corresponding
 
279
* elements of two arrays together into a new array.
 
280
* @method Array.zip
 
281
* @param a {Array} a collection to iterate over
 
282
* @param a2 {Array} another collection whose members will be 
 
283
* paired with members of the first parameter
 
284
* @static
 
285
* @return An array of arrays formed by pairing each element 
 
286
* of the first collection with an item in the second collection 
 
287
* having the corresponding index.
 
288
*/
 
289
A.zip = function (a, a2) {
 
290
    var results = [];
 
291
    A.each(a, function (item, index) {
 
292
        results.push([item, a2[index]]);
 
293
    });
 
294
    return results;
 
295
};
 
296
 
 
297
A.forEach = A.each;
 
298
 
 
299
 
 
300
}, '3.1.0' );