lib/yuilib/3.13.0/autocomplete-filters/autocomplete-filters.js

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