jssource/src_files/include/javascript/yui3/build/autocomplete/autocomplete-filters.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.3.0
   6 build: 3167
   7 */
   8 YUI.add('autocomplete-filters', function(Y) {
   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
  28      * query, 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         var queryChars = YArray.unique((caseSensitive ? query :
  41                 query.toLowerCase()).split(''));
  42
  43         return YArray.filter(results, function (result) {
  44             result = result.text;
  45
  46             if (!caseSensitive) {
  47                 result = result.toLowerCase();
  48             }
  49
  50             return YArray.every(queryChars, function (chr) {
  51                 return result.indexOf(chr) !== -1;
  52             });
  53         });
  54     },
  55
  56     /**
  57      * Case-sensitive version of <code>charMatch()</code>.
  58      *
  59      * @method charMatchCase
  60      * @param {String} query Query to match
  61      * @param {Array} results Results to filter
  62      * @return {Array} Filtered results
  63      * @static
  64      */
  65     charMatchCase: function (query, results) {
  66         return Filters.charMatch(query, results, true);
  67     },
  68
  69     /**
  70      * Returns an array of results that contain the complete query as a phrase.
  71      * Case-insensitive.
  72      *
  73      * @method phraseMatch
  74      * @param {String} query Query to match
  75      * @param {Array} results Results to filter
  76      * @return {Array} Filtered results
  77      * @static
  78      */
  79     phraseMatch: function (query, results, caseSensitive) {
  80         // The caseSensitive parameter is only intended for use by
  81         // phraseMatchCase(). It's intentionally undocumented.
  82
  83         if (!caseSensitive) {
  84             query = query.toLowerCase();
  85         }
  86
  87         return YArray.filter(results, function (result) {
  88             return (caseSensitive ? result.text : result.text.toLowerCase()).indexOf(query) !== -1;
  89         });
  90     },
  91
  92     /**
  93      * Case-sensitive version of <code>phraseMatch()</code>.
  94      *
  95      * @method phraseMatchCase
  96      * @param {String} query Query to match
  97      * @param {Array} results Results to filter
  98      * @return {Array} Filtered results
  99      * @static
 100      */
 101     phraseMatchCase: function (query, results) {
 102         return Filters.phraseMatch(query, results, true);
 103     },
 104
 105     /**
 106      * Returns an array of results that start with the complete query as a
 107      * phrase. Case-insensitive.
 108      *
 109      * @method startsWith
 110      * @param {String} query Query to match
 111      * @param {Array} results Results to filter
 112      * @return {Array} Filtered results
 113      * @static
 114      */
 115     startsWith: function (query, results, caseSensitive) {
 116         // The caseSensitive parameter is only intended for use by
 117         // startsWithCase(). It's intentionally undocumented.
 118
 119         if (!caseSensitive) {
 120             query = query.toLowerCase();
 121         }
 122
 123         return YArray.filter(results, function (result) {
 124             return (caseSensitive ? result.text : result.text.toLowerCase()).indexOf(query) === 0;
 125         });
 126     },
 127
 128     /**
 129      * Case-sensitive version of <code>startsWith()</code>.
 130      *
 131      * @method startsWithCase
 132      * @param {String} query Query to match
 133      * @param {Array} results Results to filter
 134      * @return {Array} Filtered results
 135      * @static
 136      */
 137     startsWithCase: function (query, results) {
 138         return Filters.startsWith(query, results, true);
 139     },
 140
 141     /**
 142      * Returns an array of results that contain all of the words in the query,
 143      * in any order. Non-word characters like whitespace and certain punctuation
 144      * are ignored. Case-insensitive.
 145      *
 146      * @method wordMatch
 147      * @param {String} query Query to match
 148      * @param {Array} results Results to filter
 149      * @return {Array} Filtered results
 150      * @static
 151      */
 152     wordMatch: function (query, results, caseSensitive) {
 153         // The caseSensitive parameter is only intended for use by
 154         // wordMatchCase(). It's intentionally undocumented.
 155
 156         var options    = {ignoreCase: !caseSensitive},
 157             queryWords = WordBreak.getUniqueWords(query, options);
 158
 159         return YArray.filter(results, function (result) {
 160             // Convert resultWords array to a hash for fast lookup.
 161             var resultWords = YArray.hash(WordBreak.getUniqueWords(result.text,
 162                                 options));
 163
 164             return YArray.every(queryWords, function (word) {
 165                 return YObject.owns(resultWords, word);
 166             });
 167         });
 168     },
 169
 170     /**
 171      * Case-sensitive version of <code>wordMatch()</code>.
 172      *
 173      * @method wordMatchCase
 174      * @param {String} query Query to match
 175      * @param {Array} results Results to filter
 176      * @return {Array} Filtered results
 177      * @static
 178      */
 179     wordMatchCase: function (query, results) {
 180         return Filters.wordMatch(query, results, true);
 181     }
 182 });
 183
 184
 185 }, '3.3.0' ,{requires:['array-extras', 'text-wordbreak']});