+ * Provides a basic accent folding implementation that converts common accented + * letters (like "á") to their non-accented forms (like "a"). + *
+ * + *+ * This implementation is not comprehensive, and should only be used as a last + * resort when accent folding can't be done on the server. A comprehensive + * accent folding implementation would require much more character data to be + * sent to the browser, resulting in a significant performance penalty. This + * implementation strives for a compromise between usefulness and performance. + *
+ * + *+ * Accent folding is a destructive operation that can't be reversed, and may + * change or destroy the actual meaning of the text depending on the language. + * It should not be used on strings that will later be displayed to a user, + * unless this is done with the understanding that linguistic meaning may be + * lost and that you may in fact confuse or insult the user by doing so. + *
+ * + *+ * When used for matching, accent folding is likely to produce erroneous matches + * for languages in which characters with diacritics are considered different + * from their base characters, or where correct folding would map to other + * character sequences than just stripped characters. For example, in German + * "ü" is a character that's clearly different from "u" and should match "ue" + * instead. The word "betrügen" means "to defraud", while "betrugen" is the past + * tense of "to behave". The name "Müller" is expected to match "Mueller", but + * not "Muller". On the other hand, accent folding falls short for languages + * where different base characters are expected to match. In Japanese, for + * example, hiragana and katakana characters with the same pronunciation ("あ" + * and "ア") are commonly treated as equivalent for lookups, but accent folding + * treats them as different. + *
+ * + * @class Text.AccentFold + * @static + */ + +var YArray = Y.Array, + Text = Y.Text, + FoldData = Text.Data.AccentFold, + +AccentFold = { + // -- Public Static Methods ------------------------------------------------ + + /** + * Returnstrue if the specified string contains one or more
+ * characters that can be folded, false otherwise.
+ *
+ * @method canFold
+ * @param {String} string String to test.
+ * @return {Boolean}
+ * @static
+ */
+ canFold: function (string) {
+ var letter;
+
+ for (letter in FoldData) {
+ if (FoldData.hasOwnProperty(letter) &&
+ string.search(FoldData[letter]) !== -1) {
+ return true;
+ }
+ }
+
+ return false;
+ },
+
+ /**
+ * Compares the accent-folded versions of two strings and returns
+ * true if they're the same, false otherwise. If
+ * a custom comparison function is supplied, the accent-folded strings will
+ * be passed to that function for comparison.
+ *
+ * @method compare
+ * @param {String} a First string to compare.
+ * @param {String} b Second string to compare.
+ * @param {Function} func (optional) Custom comparison function. Should
+ * return a truthy or falsy value.
+ * @return {Boolean} Results of the comparison.
+ * @static
+ */
+ compare: function (a, b, func) {
+ var aFolded = AccentFold.fold(a),
+ bFolded = AccentFold.fold(b);
+
+ return func ? !!func(aFolded, bFolded) : aFolded === bFolded;
+ },
+
+ /**
+ *
+ * Returns a copy of haystack containing only the strings for which
+ * the supplied function returns true.
+ *
+ * While comparisons will be made using accent-folded strings, the returned + * array of matches will contain the original strings that were passed in. + *
+ * + * @method filter + * @param {Array} haystack Array of strings to filter. + * @param {Function} func Comparison function. Will receive an accent-folded + * haystack string as an argument, and should return a truthy or falsy + * value. + * @return {Array} Filtered copy of haystack. + * @static + */ + filter: function (haystack, func) { + return YArray.filter(haystack, function (item) { + return func(AccentFold.fold(item)); + }); + }, + + /** + * Accent-folds the specified string or array of strings and returns a copy + * in which common accented letters have been converted to their closest + * non-accented, lowercase forms. + * + * @method fold + * @param {String|Array} input String or array of strings to be folded. + * @return {String|Array} Folded string or array of strings. + * @static + */ + fold: function (input) { + if (Y.Lang.isArray(input)) { + return YArray.map(input, AccentFold.fold); + } + + input = input.toLowerCase(); + + Y.Object.each(FoldData, function (regex, letter) { + input = input.replace(regex, letter); + }); + + return input; + } +}; + +Text.AccentFold = AccentFold; + + +}, '3.10.3', {"requires": ["array-extras", "text-data-accentfold"]});