File: autocomplete/js/autocomplete-highlighters.js

            /**
            Provides pre-built result highlighters for AutoComplete.
            
            @module autocomplete
            @submodule autocomplete-highlighters
            @class AutoCompleteHighlighters
            @static
            **/
            
            var YArray    = Y.Array,
                Highlight = Y.Highlight,
            
            Highlighters = Y.mix(Y.namespace('AutoCompleteHighlighters'), {
                // -- Public Methods -------------------------------------------------------
            
                /**
                Highlights any individual query character that occurs anywhere in a result.
                Case-insensitive.
            
                @method charMatch
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                charMatch: function (query, results, caseSensitive) {
                    // The caseSensitive parameter is only intended for use by
                    // charMatchCase(). It's intentionally undocumented.
            
                    var queryChars = YArray.unique((caseSensitive ? query :
                            query.toLowerCase()).split(''));
            
                    return YArray.map(results, function (result) {
                        return Highlight.all(result.text, queryChars, {
                            caseSensitive: caseSensitive
                        });
                    });
                },
            
                /**
                Case-sensitive version of `charMatch()`.
            
                @method charMatchCase
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                charMatchCase: function (query, results) {
                    return Highlighters.charMatch(query, results, true);
                },
            
                /**
                Highlights the complete query as a phrase anywhere within a result. Case-
                insensitive.
            
                @method phraseMatch
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                phraseMatch: function (query, results, caseSensitive) {
                    // The caseSensitive parameter is only intended for use by
                    // phraseMatchCase(). It's intentionally undocumented.
            
                    return YArray.map(results, function (result) {
                        return Highlight.all(result.text, [query], {
                            caseSensitive: caseSensitive
                        });
                    });
                },
            
                /**
                Case-sensitive version of `phraseMatch()`.
            
                @method phraseMatchCase
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                phraseMatchCase: function (query, results) {
                    return Highlighters.phraseMatch(query, results, true);
                },
            
                /**
                Highlights the complete query as a phrase at the beginning of a result.
                Case-insensitive.
            
                @method startsWith
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                startsWith: function (query, results, caseSensitive) {
                    // The caseSensitive parameter is only intended for use by
                    // startsWithCase(). It's intentionally undocumented.
            
                    return YArray.map(results, function (result) {
                        return Highlight.all(result.text, [query], {
                            caseSensitive: caseSensitive,
                            startsWith   : true
                        });
                    });
                },
            
                /**
                Case-sensitive version of `startsWith()`.
            
                @method startsWithCase
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                startsWithCase: function (query, results) {
                    return Highlighters.startsWith(query, results, true);
                },
            
                /**
                Highlights portions of results in which words from the query match either
                whole words or parts of words in the result. Non-word characters like
                whitespace and certain punctuation are ignored. Case-insensitive.
            
                @method subWordMatch
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                subWordMatch: function (query, results, caseSensitive) {
                    // The caseSensitive parameter is only intended for use by
                    // subWordMatchCase(). It's intentionally undocumented.
            
                    var queryWords = Y.Text.WordBreak.getUniqueWords(query, {
                        ignoreCase: !caseSensitive
                    });
            
                    return YArray.map(results, function (result) {
                        return Highlight.all(result.text, queryWords, {
                            caseSensitive: caseSensitive
                        });
                    });
                },
            
                /**
                Case-sensitive version of `subWordMatch()`.
            
                @method subWordMatchCase
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                subWordMatchCase: function (query, results) {
                    return Highlighters.subWordMatch(query, results, true);
                },
            
                /**
                Highlights individual words in results that are also in the query. Non-word
                characters like punctuation are ignored. Case-insensitive.
            
                @method wordMatch
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                wordMatch: function (query, results, caseSensitive) {
                    // The caseSensitive parameter is only intended for use by
                    // wordMatchCase(). It's intentionally undocumented.
            
                    return YArray.map(results, function (result) {
                        return Highlight.words(result.text, query, {
                            caseSensitive: caseSensitive
                        });
                    });
                },
            
                /**
                Case-sensitive version of `wordMatch()`.
            
                @method wordMatchCase
                @param {String} query Query to match
                @param {Array} results Results to highlight
                @return {Array} Highlighted results
                @static
                **/
                wordMatchCase: function (query, results) {
                    return Highlighters.wordMatch(query, results, true);
                }
            });