--- /dev/null
+<!DOCTYPE html><html><head><title>Sencha Documentation Project</title><link rel="stylesheet" href="../reset.css" type="text/css"><link rel="stylesheet" href="../prettify.css" type="text/css"><link rel="stylesheet" href="../prettify_sa.css" type="text/css"><script type="text/javascript" src="../prettify.js"></script></head><body onload="prettyPrint()"><pre class="prettyprint"><pre><span id='Ext-util.Inflector'>/**
+</span> * @class Ext.util.Inflector
+ * @extends Object
+ * <p>General purpose inflector class that {@link #pluralize pluralizes}, {@link #singularize singularizes} and
+ * {@link #ordinalize ordinalizes} words. Sample usage:</p>
+ *
+<pre><code>
+//turning singular words into plurals
+Ext.util.Inflector.pluralize('word'); //'words'
+Ext.util.Inflector.pluralize('person'); //'people'
+Ext.util.Inflector.pluralize('sheep'); //'sheep'
+
+//turning plurals into singulars
+Ext.util.Inflector.singularize('words'); //'word'
+Ext.util.Inflector.singularize('people'); //'person'
+Ext.util.Inflector.singularize('sheep'); //'sheep'
+
+//ordinalizing numbers
+Ext.util.Inflector.ordinalize(11); //"11th"
+Ext.util.Inflector.ordinalize(21); //"21th"
+Ext.util.Inflector.ordinalize(1043); //"1043rd"
+</code></pre>
+ *
+ * <p><u>Customization</u></p>
+ *
+ * <p>The Inflector comes with a default set of US English pluralization rules. These can be augmented with additional
+ * rules if the default rules do not meet your application's requirements, or swapped out entirely for other languages.
+ * Here is how we might add a rule that pluralizes "ox" to "oxen":</p>
+ *
+<pre><code>
+Ext.util.Inflector.plural(/^(ox)$/i, "$1en");
+</code></pre>
+ *
+ * <p>Each rule consists of two items - a regular expression that matches one or more rules, and a replacement string.
+ * In this case, the regular expression will only match the string "ox", and will replace that match with "oxen".
+ * Here's how we could add the inverse rule:</p>
+ *
+<pre><code>
+Ext.util.Inflector.singular(/^(ox)en$/i, "$1");
+</code></pre>
+ *
+ * <p>Note that the ox/oxen rules are present by default.</p>
+ *
+ * @singleton
+ */
+
+Ext.define('Ext.util.Inflector', {
+
+ /* Begin Definitions */
+
+ singleton: true,
+
+ /* End Definitions */
+
+<span id='Ext-util.Inflector-property-plurals'> /**
+</span> * @private
+ * The registered plural tuples. Each item in the array should contain two items - the first must be a regular
+ * expression that matchers the singular form of a word, the second must be a String that replaces the matched
+ * part of the regular expression. This is managed by the {@link #plural} method.
+ * @property plurals
+ * @type Array
+ */
+ plurals: [
+ [(/(quiz)$/i), "$1zes" ],
+ [(/^(ox)$/i), "$1en" ],
+ [(/([m|l])ouse$/i), "$1ice" ],
+ [(/(matr|vert|ind)ix|ex$/i), "$1ices" ],
+ [(/(x|ch|ss|sh)$/i), "$1es" ],
+ [(/([^aeiouy]|qu)y$/i), "$1ies" ],
+ [(/(hive)$/i), "$1s" ],
+ [(/(?:([^f])fe|([lr])f)$/i), "$1$2ves"],
+ [(/sis$/i), "ses" ],
+ [(/([ti])um$/i), "$1a" ],
+ [(/(buffal|tomat|potat)o$/i), "$1oes" ],
+ [(/(bu)s$/i), "$1ses" ],
+ [(/(alias|status|sex)$/i), "$1es" ],
+ [(/(octop|vir)us$/i), "$1i" ],
+ [(/(ax|test)is$/i), "$1es" ],
+ [(/^person$/), "people" ],
+ [(/^man$/), "men" ],
+ [(/^(child)$/), "$1ren" ],
+ [(/s$/i), "s" ],
+ [(/$/), "s" ]
+ ],
+
+<span id='Ext-util.Inflector-property-singulars'> /**
+</span> * @private
+ * The set of registered singular matchers. Each item in the array should contain two items - the first must be a
+ * regular expression that matches the plural form of a word, the second must be a String that replaces the
+ * matched part of the regular expression. This is managed by the {@link #singular} method.
+ * @property singulars
+ * @type Array
+ */
+ singulars: [
+ [(/(quiz)zes$/i), "$1" ],
+ [(/(matr)ices$/i), "$1ix" ],
+ [(/(vert|ind)ices$/i), "$1ex" ],
+ [(/^(ox)en/i), "$1" ],
+ [(/(alias|status)es$/i), "$1" ],
+ [(/(octop|vir)i$/i), "$1us" ],
+ [(/(cris|ax|test)es$/i), "$1is" ],
+ [(/(shoe)s$/i), "$1" ],
+ [(/(o)es$/i), "$1" ],
+ [(/(bus)es$/i), "$1" ],
+ [(/([m|l])ice$/i), "$1ouse" ],
+ [(/(x|ch|ss|sh)es$/i), "$1" ],
+ [(/(m)ovies$/i), "$1ovie" ],
+ [(/(s)eries$/i), "$1eries"],
+ [(/([^aeiouy]|qu)ies$/i), "$1y" ],
+ [(/([lr])ves$/i), "$1f" ],
+ [(/(tive)s$/i), "$1" ],
+ [(/(hive)s$/i), "$1" ],
+ [(/([^f])ves$/i), "$1fe" ],
+ [(/(^analy)ses$/i), "$1sis" ],
+ [(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i), "$1$2sis"],
+ [(/([ti])a$/i), "$1um" ],
+ [(/(n)ews$/i), "$1ews" ],
+ [(/people$/i), "person" ],
+ [(/s$/i), "" ]
+ ],
+
+<span id='Ext-util.Inflector-property-uncountable'> /**
+</span> * @private
+ * The registered uncountable words
+ * @property uncountable
+ * @type Array
+ */
+ uncountable: [
+ "sheep",
+ "fish",
+ "series",
+ "species",
+ "money",
+ "rice",
+ "information",
+ "equipment",
+ "grass",
+ "mud",
+ "offspring",
+ "deer",
+ "means"
+ ],
+
+<span id='Ext-util.Inflector-method-singular'> /**
+</span> * Adds a new singularization rule to the Inflector. See the intro docs for more information
+ * @param {RegExp} matcher The matcher regex
+ * @param {String} replacer The replacement string, which can reference matches from the matcher argument
+ */
+ singular: function(matcher, replacer) {
+ this.singulars.unshift([matcher, replacer]);
+ },
+
+<span id='Ext-util.Inflector-method-plural'> /**
+</span> * Adds a new pluralization rule to the Inflector. See the intro docs for more information
+ * @param {RegExp} matcher The matcher regex
+ * @param {String} replacer The replacement string, which can reference matches from the matcher argument
+ */
+ plural: function(matcher, replacer) {
+ this.plurals.unshift([matcher, replacer]);
+ },
+
+<span id='Ext-util.Inflector-method-clearSingulars'> /**
+</span> * Removes all registered singularization rules
+ */
+ clearSingulars: function() {
+ this.singulars = [];
+ },
+
+<span id='Ext-util.Inflector-method-clearPlurals'> /**
+</span> * Removes all registered pluralization rules
+ */
+ clearPlurals: function() {
+ this.plurals = [];
+ },
+
+<span id='Ext-util.Inflector-method-isTransnumeral'> /**
+</span> * Returns true if the given word is transnumeral (the word is its own singular and plural form - e.g. sheep, fish)
+ * @param {String} word The word to test
+ * @return {Boolean} True if the word is transnumeral
+ */
+ isTransnumeral: function(word) {
+ return Ext.Array.indexOf(this.uncountable, word) != -1;
+ },
+
+<span id='Ext-util.Inflector-method-pluralize'> /**
+</span> * Returns the pluralized form of a word (e.g. Ext.util.Inflector.pluralize('word') returns 'words')
+ * @param {String} word The word to pluralize
+ * @return {String} The pluralized form of the word
+ */
+ pluralize: function(word) {
+ if (this.isTransnumeral(word)) {
+ return word;
+ }
+
+ var plurals = this.plurals,
+ length = plurals.length,
+ tuple, regex, i;
+
+ for (i = 0; i < length; i++) {
+ tuple = plurals[i];
+ regex = tuple[0];
+
+ if (regex == word || (regex.test && regex.test(word))) {
+ return word.replace(regex, tuple[1]);
+ }
+ }
+
+ return word;
+ },
+
+<span id='Ext-util.Inflector-method-singularize'> /**
+</span> * Returns the singularized form of a word (e.g. Ext.util.Inflector.singularize('words') returns 'word')
+ * @param {String} word The word to singularize
+ * @return {String} The singularized form of the word
+ */
+ singularize: function(word) {
+ if (this.isTransnumeral(word)) {
+ return word;
+ }
+
+ var singulars = this.singulars,
+ length = singulars.length,
+ tuple, regex, i;
+
+ for (i = 0; i < length; i++) {
+ tuple = singulars[i];
+ regex = tuple[0];
+
+ if (regex == word || (regex.test && regex.test(word))) {
+ return word.replace(regex, tuple[1]);
+ }
+ }
+
+ return word;
+ },
+
+<span id='Ext-util.Inflector-method-classify'> /**
+</span> * Returns the correct {@link Ext.data.Model Model} name for a given string. Mostly used internally by the data
+ * package
+ * @param {String} word The word to classify
+ * @return {String} The classified version of the word
+ */
+ classify: function(word) {
+ return Ext.String.capitalize(this.singularize(word));
+ },
+
+<span id='Ext-util.Inflector-method-ordinalize'> /**
+</span> * Ordinalizes a given number by adding a prefix such as 'st', 'nd', 'rd' or 'th' based on the last digit of the
+ * number. 21 -> 21st, 22 -> 22nd, 23 -> 23rd, 24 -> 24th etc
+ * @param {Number} number The number to ordinalize
+ * @return {String} The ordinalized number
+ */
+ ordinalize: function(number) {
+ var parsed = parseInt(number, 10),
+ mod10 = parsed % 10,
+ mod100 = parsed % 100;
+
+ //11 through 13 are a special case
+ if (11 <= mod100 && mod100 <= 13) {
+ return number + "th";
+ } else {
+ switch(mod10) {
+ case 1 : return number + "st";
+ case 2 : return number + "nd";
+ case 3 : return number + "rd";
+ default: return number + "th";
+ }
+ }
+ }
+}, function() {
+ //aside from the rules above, there are a number of words that have irregular pluralization so we add them here
+ var irregulars = {
+ alumnus: 'alumni',
+ cactus : 'cacti',
+ focus : 'foci',
+ nucleus: 'nuclei',
+ radius: 'radii',
+ stimulus: 'stimuli',
+ ellipsis: 'ellipses',
+ paralysis: 'paralyses',
+ oasis: 'oases',
+ appendix: 'appendices',
+ index: 'indexes',
+ beau: 'beaux',
+ bureau: 'bureaux',
+ tableau: 'tableaux',
+ woman: 'women',
+ child: 'children',
+ man: 'men',
+ corpus: 'corpora',
+ criterion: 'criteria',
+ curriculum: 'curricula',
+ genus: 'genera',
+ memorandum: 'memoranda',
+ phenomenon: 'phenomena',
+ foot: 'feet',
+ goose: 'geese',
+ tooth: 'teeth',
+ antenna: 'antennae',
+ formula: 'formulae',
+ nebula: 'nebulae',
+ vertebra: 'vertebrae',
+ vita: 'vitae'
+ },
+ singular;
+
+ for (singular in irregulars) {
+ this.plural(singular, irregulars[singular]);
+ this.singular(irregulars[singular], singular);
+ }
+});</pre></pre></body></html>
\ No newline at end of file
git.ithinksw.org / extjs.git / blobdiff