← Back to branch summary

~smagoun/whoopsie/whoopsie-lp1017637

« back to all changes in this revision

Viewing changes to backend/stats/static/js/yui/build/autocomplete-filters/autocomplete-filters.js

  • Committer: Evan Dandrea
  • Date: 2012-05-09 05:53:45 UTC
  • Revision ID: evan.dandrea@canonical.com-20120509055345-z2j41tmcbf4as5uf
The backend now lives in lp:daisy and the website (errors.ubuntu.com) now lives in lp:errors.

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend/stats/static/js/yui/build/autocomplete-filters/autocomplete-filters.js
1
 
/*
2
 
YUI 3.5.0 (build 5089)
3
 
Copyright 2012 Yahoo! Inc. All rights reserved.
4
 
Licensed under the BSD License.
5
 
http://yuilibrary.com/license/
6
 
*/
7
 
YUI.add('autocomplete-filters', function(Y) {
8
 
 
9
 
/**
10
 
Provides pre-built result matching filters for AutoComplete.
11
 
 
12
 
@module autocomplete
13
 
@submodule autocomplete-filters
14
 
@class AutoCompleteFilters
15
 
@static
16
 
**/
17
 
 
18
 
var YArray     = Y.Array,
19
 
    YObject    = Y.Object,
20
 
    WordBreak  = Y.Text.WordBreak,
21
 
 
22
 
Filters = Y.mix(Y.namespace('AutoCompleteFilters'), {
23
 
    // -- Public Methods -------------------------------------------------------
24
 
 
25
 
    /**
26
 
    Returns an array of results that contain all of the characters in the query,
27
 
    in any order (not necessarily consecutive). Case-insensitive.
28
 
 
29
 
    @method charMatch
30
 
    @param {String} query Query to match
31
 
    @param {Array} results Results to filter
32
 
    @return {Array} Filtered results
33
 
    @static
34
 
    **/
35
 
    charMatch: function (query, results, caseSensitive) {
36
 
        // The caseSensitive parameter is only intended for use by
37
 
        // charMatchCase(). It's intentionally undocumented.
38
 
 
39
 
        if (!query) { return results; }
40
 
 
41
 
        var queryChars = YArray.unique((caseSensitive ? query :
42
 
                query.toLowerCase()).split(''));
43
 
 
44
 
        return YArray.filter(results, function (result) {
45
 
            result = result.text;
46
 
 
47
 
            if (!caseSensitive) {
48
 
                result = result.toLowerCase();
49
 
            }
50
 
 
51
 
            return YArray.every(queryChars, function (chr) {
52
 
                return result.indexOf(chr) !== -1;
53
 
            });
54
 
        });
55
 
    },
56
 
 
57
 
    /**
58
 
    Case-sensitive version of `charMatch()`.
59
 
 
60
 
    @method charMatchCase
61
 
    @param {String} query Query to match
62
 
    @param {Array} results Results to filter
63
 
    @return {Array} Filtered results
64
 
    @static
65
 
    **/
66
 
    charMatchCase: function (query, results) {
67
 
        return Filters.charMatch(query, results, true);
68
 
    },
69
 
 
70
 
    /**
71
 
    Returns an array of results that contain the complete query as a phrase.
72
 
    Case-insensitive.
73
 
 
74
 
    @method phraseMatch
75
 
    @param {String} query Query to match
76
 
    @param {Array} results Results to filter
77
 
    @return {Array} Filtered results
78
 
    @static
79
 
    **/
80
 
    phraseMatch: function (query, results, caseSensitive) {
81
 
        // The caseSensitive parameter is only intended for use by
82
 
        // phraseMatchCase(). It's intentionally undocumented.
83
 
 
84
 
        if (!query) { return results; }
85
 
 
86
 
        if (!caseSensitive) {
87
 
            query = query.toLowerCase();
88
 
        }
89
 
 
90
 
        return YArray.filter(results, function (result) {
91
 
            return (caseSensitive ? result.text : result.text.toLowerCase()).indexOf(query) !== -1;
92
 
        });
93
 
    },
94
 
 
95
 
    /**
96
 
    Case-sensitive version of `phraseMatch()`.
97
 
 
98
 
    @method phraseMatchCase
99
 
    @param {String} query Query to match
100
 
    @param {Array} results Results to filter
101
 
    @return {Array} Filtered results
102
 
    @static
103
 
    **/
104
 
    phraseMatchCase: function (query, results) {
105
 
        return Filters.phraseMatch(query, results, true);
106
 
    },
107
 
 
108
 
    /**
109
 
    Returns an array of results that start with the complete query as a phrase.
110
 
    Case-insensitive.
111
 
 
112
 
    @method startsWith
113
 
    @param {String} query Query to match
114
 
    @param {Array} results Results to filter
115
 
    @return {Array} Filtered results
116
 
    @static
117
 
    **/
118
 
    startsWith: function (query, results, caseSensitive) {
119
 
        // The caseSensitive parameter is only intended for use by
120
 
        // startsWithCase(). It's intentionally undocumented.
121
 
 
122
 
        if (!query) { return results; }
123
 
 
124
 
        if (!caseSensitive) {
125
 
            query = query.toLowerCase();
126
 
        }
127
 
 
128
 
        return YArray.filter(results, function (result) {
129
 
            return (caseSensitive ? result.text : result.text.toLowerCase()).indexOf(query) === 0;
130
 
        });
131
 
    },
132
 
 
133
 
    /**
134
 
    Case-sensitive version of `startsWith()`.
135
 
 
136
 
    @method startsWithCase
137
 
    @param {String} query Query to match
138
 
    @param {Array} results Results to filter
139
 
    @return {Array} Filtered results
140
 
    @static
141
 
    **/
142
 
    startsWithCase: function (query, results) {
143
 
        return Filters.startsWith(query, results, true);
144
 
    },
145
 
 
146
 
    /**
147
 
    Returns an array of results in which all the words of the query match either
148
 
    whole words or parts of words in the result. Non-word characters like
149
 
    whitespace and certain punctuation are ignored. Case-insensitive.
150
 
 
151
 
    This is basically a combination of `wordMatch()` (by ignoring whitespace and
152
 
    word order) and `phraseMatch()` (by allowing partial matching instead of
153
 
    requiring the entire word to match).
154
 
 
155
 
    Example use case: Trying to find personal names independently of name order
156
 
    (Western or Eastern order) and supporting immediate feedback by allowing
157
 
    partial occurences. So queries like "J. Doe", "Doe, John", and "J. D." would
158
 
    all match "John Doe".
159
 
 
160
 
    @method subWordMatch
161
 
    @param {String} query Query to match
162
 
    @param {Array} results Results to filter
163
 
    @return {Array} Filtered results
164
 
    @static
165
 
    **/
166
 
    subWordMatch: function (query, results, caseSensitive) {
167
 
        // The caseSensitive parameter is only intended for use by
168
 
        // subWordMatchCase(). It's intentionally undocumented.
169
 
 
170
 
        if (!query) { return results; }
171
 
 
172
 
        var queryWords = WordBreak.getUniqueWords(query, {
173
 
            ignoreCase: !caseSensitive
174
 
        });
175
 
 
176
 
        return YArray.filter(results, function (result) {
177
 
            var resultText = caseSensitive ? result.text :
178
 
                    result.text.toLowerCase();
179
 
 
180
 
            return YArray.every(queryWords, function (queryWord) {
181
 
                return resultText.indexOf(queryWord) !== -1;
182
 
            });
183
 
        });
184
 
    },
185
 
 
186
 
    /**
187
 
    Case-sensitive version of `subWordMatch()`.
188
 
 
189
 
    @method subWordMatchCase
190
 
    @param {String} query Query to match
191
 
    @param {Array} results Results to filter
192
 
    @return {Array} Filtered results
193
 
    @static
194
 
    **/
195
 
    subWordMatchCase: function (query, results) {
196
 
        return Filters.subWordMatch(query, results, true);
197
 
    },
198
 
 
199
 
    /**
200
 
    Returns an array of results that contain all of the words in the query, in
201
 
    any order. Non-word characters like whitespace and certain punctuation are
202
 
    ignored. Case-insensitive.
203
 
 
204
 
    @method wordMatch
205
 
    @param {String} query Query to match
206
 
    @param {Array} results Results to filter
207
 
    @return {Array} Filtered results
208
 
    @static
209
 
    **/
210
 
    wordMatch: function (query, results, caseSensitive) {
211
 
        // The caseSensitive parameter is only intended for use by
212
 
        // wordMatchCase(). It's intentionally undocumented.
213
 
 
214
 
        if (!query) { return results; }
215
 
 
216
 
        var options    = {ignoreCase: !caseSensitive},
217
 
            queryWords = WordBreak.getUniqueWords(query, options);
218
 
 
219
 
        return YArray.filter(results, function (result) {
220
 
            // Convert resultWords array to a hash for fast lookup.
221
 
            var resultWords = YArray.hash(WordBreak.getUniqueWords(result.text,
222
 
                                options));
223
 
 
224
 
            return YArray.every(queryWords, function (word) {
225
 
                return YObject.owns(resultWords, word);
226
 
            });
227
 
        });
228
 
    },
229
 
 
230
 
    /**
231
 
    Case-sensitive version of `wordMatch()`.
232
 
 
233
 
    @method wordMatchCase
234
 
    @param {String} query Query to match
235
 
    @param {Array} results Results to filter
236
 
    @return {Array} Filtered results
237
 
    @static
238
 
    **/
239
 
    wordMatchCase: function (query, results) {
240
 
        return Filters.wordMatch(query, results, true);
241
 
    }
242
 
});
243
 
 
244
 
 
245
 
}, '3.5.0' ,{requires:['array-extras', 'text-wordbreak']});