| /*! |
| * inflection |
| * Copyright(c) 2011 Ben Lin <ben@dreamerslab.com> |
| * MIT Licensed |
| * |
| * @fileoverview |
| * A port of inflection-js to node.js module. |
| */ |
| |
| ( function ( root, factory ){ |
| if( typeof define === 'function' && define.amd ){ |
| define([], factory ); |
| }else if( typeof exports === 'object' ){ |
| module.exports = factory(); |
| }else{ |
| root.inflection = factory(); |
| } |
| }( this, function (){ |
| |
| /** |
| * @description This is a list of nouns that use the same form for both singular and plural. |
| * This list should remain entirely in lower case to correctly match Strings. |
| * @private |
| */ |
| var uncountable_words = [ |
| // 'access', |
| 'accommodation', |
| 'adulthood', |
| 'advertising', |
| 'advice', |
| 'aggression', |
| 'aid', |
| 'air', |
| 'aircraft', |
| 'alcohol', |
| 'anger', |
| 'applause', |
| 'arithmetic', |
| // 'art', |
| 'assistance', |
| 'athletics', |
| // 'attention', |
| |
| 'bacon', |
| 'baggage', |
| // 'ballet', |
| // 'beauty', |
| 'beef', |
| // 'beer', |
| // 'behavior', |
| 'biology', |
| // 'billiards', |
| 'blood', |
| 'botany', |
| // 'bowels', |
| 'bread', |
| // 'business', |
| 'butter', |
| |
| 'carbon', |
| 'cardboard', |
| 'cash', |
| 'chalk', |
| 'chaos', |
| 'chess', |
| 'crossroads', |
| 'countryside', |
| |
| // 'damage', |
| 'dancing', |
| // 'danger', |
| 'deer', |
| // 'delight', |
| // 'dessert', |
| 'dignity', |
| 'dirt', |
| // 'distribution', |
| 'dust', |
| |
| 'economics', |
| 'education', |
| 'electricity', |
| // 'employment', |
| // 'energy', |
| 'engineering', |
| 'enjoyment', |
| // 'entertainment', |
| 'envy', |
| 'equipment', |
| 'ethics', |
| 'evidence', |
| 'evolution', |
| |
| // 'failure', |
| // 'faith', |
| 'fame', |
| 'fiction', |
| // 'fish', |
| 'flour', |
| 'flu', |
| 'food', |
| // 'freedom', |
| // 'fruit', |
| 'fuel', |
| 'fun', |
| // 'funeral', |
| 'furniture', |
| |
| 'gallows', |
| 'garbage', |
| 'garlic', |
| // 'gas', |
| 'genetics', |
| // 'glass', |
| 'gold', |
| 'golf', |
| 'gossip', |
| 'grammar', |
| // 'grass', |
| 'gratitude', |
| 'grief', |
| // 'ground', |
| 'guilt', |
| 'gymnastics', |
| |
| // 'hair', |
| 'happiness', |
| 'hardware', |
| 'harm', |
| 'hate', |
| 'hatred', |
| 'health', |
| 'heat', |
| // 'height', |
| 'help', |
| 'homework', |
| 'honesty', |
| 'honey', |
| 'hospitality', |
| 'housework', |
| 'humour', |
| 'hunger', |
| 'hydrogen', |
| |
| 'ice', |
| 'importance', |
| 'inflation', |
| 'information', |
| // 'injustice', |
| 'innocence', |
| // 'intelligence', |
| 'iron', |
| 'irony', |
| |
| 'jam', |
| // 'jealousy', |
| // 'jelly', |
| 'jewelry', |
| // 'joy', |
| 'judo', |
| // 'juice', |
| // 'justice', |
| |
| 'karate', |
| // 'kindness', |
| 'knowledge', |
| |
| // 'labour', |
| 'lack', |
| // 'land', |
| 'laughter', |
| 'lava', |
| 'leather', |
| 'leisure', |
| 'lightning', |
| 'linguine', |
| 'linguini', |
| 'linguistics', |
| 'literature', |
| 'litter', |
| 'livestock', |
| 'logic', |
| 'loneliness', |
| // 'love', |
| 'luck', |
| 'luggage', |
| |
| 'macaroni', |
| 'machinery', |
| 'magic', |
| // 'mail', |
| 'management', |
| 'mankind', |
| 'marble', |
| 'mathematics', |
| 'mayonnaise', |
| 'measles', |
| // 'meat', |
| // 'metal', |
| 'methane', |
| 'milk', |
| 'money', |
| // 'moose', |
| 'mud', |
| 'music', |
| 'mumps', |
| |
| 'nature', |
| 'news', |
| 'nitrogen', |
| 'nonsense', |
| 'nurture', |
| 'nutrition', |
| |
| 'obedience', |
| 'obesity', |
| // 'oil', |
| 'oxygen', |
| |
| // 'paper', |
| // 'passion', |
| 'pasta', |
| 'patience', |
| // 'permission', |
| 'physics', |
| 'poetry', |
| 'pollution', |
| 'poverty', |
| // 'power', |
| 'pride', |
| // 'production', |
| // 'progress', |
| // 'pronunciation', |
| 'psychology', |
| 'publicity', |
| 'punctuation', |
| |
| // 'quality', |
| // 'quantity', |
| 'quartz', |
| |
| 'racism', |
| // 'rain', |
| // 'recreation', |
| 'relaxation', |
| 'reliability', |
| 'research', |
| 'respect', |
| 'revenge', |
| 'rice', |
| 'rubbish', |
| 'rum', |
| |
| 'safety', |
| // 'salad', |
| // 'salt', |
| // 'sand', |
| // 'satire', |
| 'scenery', |
| 'seafood', |
| 'seaside', |
| 'series', |
| 'shame', |
| 'sheep', |
| 'shopping', |
| // 'silence', |
| 'sleep', |
| // 'slang' |
| 'smoke', |
| 'smoking', |
| 'snow', |
| 'soap', |
| 'software', |
| 'soil', |
| // 'sorrow', |
| // 'soup', |
| 'spaghetti', |
| // 'speed', |
| 'species', |
| // 'spelling', |
| // 'sport', |
| 'steam', |
| // 'strength', |
| 'stuff', |
| 'stupidity', |
| // 'success', |
| // 'sugar', |
| 'sunshine', |
| 'symmetry', |
| |
| // 'tea', |
| 'tennis', |
| 'thirst', |
| 'thunder', |
| 'timber', |
| // 'time', |
| // 'toast', |
| // 'tolerance', |
| // 'trade', |
| 'traffic', |
| 'transportation', |
| // 'travel', |
| 'trust', |
| |
| // 'understanding', |
| 'underwear', |
| 'unemployment', |
| 'unity', |
| // 'usage', |
| |
| 'validity', |
| 'veal', |
| 'vegetation', |
| 'vegetarianism', |
| 'vengeance', |
| 'violence', |
| // 'vision', |
| 'vitality', |
| |
| 'warmth', |
| // 'water', |
| 'wealth', |
| 'weather', |
| // 'weight', |
| 'welfare', |
| 'wheat', |
| // 'whiskey', |
| // 'width', |
| 'wildlife', |
| // 'wine', |
| 'wisdom', |
| // 'wood', |
| // 'wool', |
| // 'work', |
| |
| // 'yeast', |
| 'yoga', |
| |
| 'zinc', |
| 'zoology' |
| ]; |
| |
| /** |
| * @description These rules translate from the singular form of a noun to its plural form. |
| * @private |
| */ |
| |
| var regex = { |
| plural : { |
| men : new RegExp( '^(m|wom)en$' , 'gi' ), |
| people : new RegExp( '(pe)ople$' , 'gi' ), |
| children : new RegExp( '(child)ren$' , 'gi' ), |
| tia : new RegExp( '([ti])a$' , 'gi' ), |
| analyses : new RegExp( '((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$','gi' ), |
| hives : new RegExp( '(hi|ti)ves$' , 'gi' ), |
| curves : new RegExp( '(curve)s$' , 'gi' ), |
| lrves : new RegExp( '([lr])ves$' , 'gi' ), |
| foves : new RegExp( '([^fo])ves$' , 'gi' ), |
| movies : new RegExp( '(m)ovies$' , 'gi' ), |
| aeiouyies : new RegExp( '([^aeiouy]|qu)ies$' , 'gi' ), |
| series : new RegExp( '(s)eries$' , 'gi' ), |
| xes : new RegExp( '(x|ch|ss|sh)es$' , 'gi' ), |
| mice : new RegExp( '([m|l])ice$' , 'gi' ), |
| buses : new RegExp( '(bus)es$' , 'gi' ), |
| oes : new RegExp( '(o)es$' , 'gi' ), |
| shoes : new RegExp( '(shoe)s$' , 'gi' ), |
| crises : new RegExp( '(cris|ax|test)es$' , 'gi' ), |
| octopi : new RegExp( '(octop|vir)i$' , 'gi' ), |
| aliases : new RegExp( '(alias|canvas|status|campus)es$', 'gi' ), |
| summonses : new RegExp( '^(summons)es$' , 'gi' ), |
| oxen : new RegExp( '^(ox)en' , 'gi' ), |
| matrices : new RegExp( '(matr)ices$' , 'gi' ), |
| vertices : new RegExp( '(vert|ind)ices$' , 'gi' ), |
| feet : new RegExp( '^feet$' , 'gi' ), |
| teeth : new RegExp( '^teeth$' , 'gi' ), |
| geese : new RegExp( '^geese$' , 'gi' ), |
| quizzes : new RegExp( '(quiz)zes$' , 'gi' ), |
| whereases : new RegExp( '^(whereas)es$' , 'gi' ), |
| criteria : new RegExp( '^(criteri)a$' , 'gi' ), |
| genera : new RegExp( '^genera$' , 'gi' ), |
| ss : new RegExp( 'ss$' , 'gi' ), |
| s : new RegExp( 's$' , 'gi' ) |
| }, |
| |
| singular : { |
| man : new RegExp( '^(m|wom)an$' , 'gi' ), |
| person : new RegExp( '(pe)rson$' , 'gi' ), |
| child : new RegExp( '(child)$' , 'gi' ), |
| ox : new RegExp( '^(ox)$' , 'gi' ), |
| axis : new RegExp( '(ax|test)is$' , 'gi' ), |
| octopus : new RegExp( '(octop|vir)us$' , 'gi' ), |
| alias : new RegExp( '(alias|status|canvas|campus)$', 'gi' ), |
| summons : new RegExp( '^(summons)$' , 'gi' ), |
| bus : new RegExp( '(bu)s$' , 'gi' ), |
| buffalo : new RegExp( '(buffal|tomat|potat)o$' , 'gi' ), |
| tium : new RegExp( '([ti])um$' , 'gi' ), |
| sis : new RegExp( 'sis$' , 'gi' ), |
| ffe : new RegExp( '(?:([^f])fe|([lr])f)$' , 'gi' ), |
| hive : new RegExp( '(hi|ti)ve$' , 'gi' ), |
| aeiouyy : new RegExp( '([^aeiouy]|qu)y$' , 'gi' ), |
| x : new RegExp( '(x|ch|ss|sh)$' , 'gi' ), |
| matrix : new RegExp( '(matr)ix$' , 'gi' ), |
| vertex : new RegExp( '(vert|ind)ex$' , 'gi' ), |
| mouse : new RegExp( '([m|l])ouse$' , 'gi' ), |
| foot : new RegExp( '^foot$' , 'gi' ), |
| tooth : new RegExp( '^tooth$' , 'gi' ), |
| goose : new RegExp( '^goose$' , 'gi' ), |
| quiz : new RegExp( '(quiz)$' , 'gi' ), |
| whereas : new RegExp( '^(whereas)$' , 'gi' ), |
| criterion : new RegExp( '^(criteri)on$' , 'gi' ), |
| genus : new RegExp( '^genus$' , 'gi' ), |
| s : new RegExp( 's$' , 'gi' ), |
| common : new RegExp( '$' , 'gi' ) |
| } |
| }; |
| |
| var plural_rules = [ |
| |
| // do not replace if its already a plural word |
| [ regex.plural.men ], |
| [ regex.plural.people ], |
| [ regex.plural.children ], |
| [ regex.plural.tia ], |
| [ regex.plural.analyses ], |
| [ regex.plural.hives ], |
| [ regex.plural.curves ], |
| [ regex.plural.lrves ], |
| [ regex.plural.foves ], |
| [ regex.plural.aeiouyies ], |
| [ regex.plural.series ], |
| [ regex.plural.movies ], |
| [ regex.plural.xes ], |
| [ regex.plural.mice ], |
| [ regex.plural.buses ], |
| [ regex.plural.oes ], |
| [ regex.plural.shoes ], |
| [ regex.plural.crises ], |
| [ regex.plural.octopi ], |
| [ regex.plural.aliases ], |
| [ regex.plural.summonses ], |
| [ regex.plural.oxen ], |
| [ regex.plural.matrices ], |
| [ regex.plural.feet ], |
| [ regex.plural.teeth ], |
| [ regex.plural.geese ], |
| [ regex.plural.quizzes ], |
| [ regex.plural.whereases ], |
| [ regex.plural.criteria ], |
| [ regex.plural.genera ], |
| |
| // original rule |
| [ regex.singular.man , '$1en' ], |
| [ regex.singular.person , '$1ople' ], |
| [ regex.singular.child , '$1ren' ], |
| [ regex.singular.ox , '$1en' ], |
| [ regex.singular.axis , '$1es' ], |
| [ regex.singular.octopus , '$1i' ], |
| [ regex.singular.alias , '$1es' ], |
| [ regex.singular.summons , '$1es' ], |
| [ regex.singular.bus , '$1ses' ], |
| [ regex.singular.buffalo , '$1oes' ], |
| [ regex.singular.tium , '$1a' ], |
| [ regex.singular.sis , 'ses' ], |
| [ regex.singular.ffe , '$1$2ves' ], |
| [ regex.singular.hive , '$1ves' ], |
| [ regex.singular.aeiouyy , '$1ies' ], |
| [ regex.singular.matrix , '$1ices' ], |
| [ regex.singular.vertex , '$1ices' ], |
| [ regex.singular.x , '$1es' ], |
| [ regex.singular.mouse , '$1ice' ], |
| [ regex.singular.foot , 'feet' ], |
| [ regex.singular.tooth , 'teeth' ], |
| [ regex.singular.goose , 'geese' ], |
| [ regex.singular.quiz , '$1zes' ], |
| [ regex.singular.whereas , '$1es' ], |
| [ regex.singular.criterion, '$1a' ], |
| [ regex.singular.genus , 'genera' ], |
| |
| [ regex.singular.s , 's' ], |
| [ regex.singular.common, 's' ] |
| ]; |
| |
| /** |
| * @description These rules translate from the plural form of a noun to its singular form. |
| * @private |
| */ |
| var singular_rules = [ |
| |
| // do not replace if its already a singular word |
| [ regex.singular.man ], |
| [ regex.singular.person ], |
| [ regex.singular.child ], |
| [ regex.singular.ox ], |
| [ regex.singular.axis ], |
| [ regex.singular.octopus ], |
| [ regex.singular.alias ], |
| [ regex.singular.summons ], |
| [ regex.singular.bus ], |
| [ regex.singular.buffalo ], |
| [ regex.singular.tium ], |
| [ regex.singular.sis ], |
| [ regex.singular.ffe ], |
| [ regex.singular.hive ], |
| [ regex.singular.aeiouyy ], |
| [ regex.singular.x ], |
| [ regex.singular.matrix ], |
| [ regex.singular.mouse ], |
| [ regex.singular.foot ], |
| [ regex.singular.tooth ], |
| [ regex.singular.goose ], |
| [ regex.singular.quiz ], |
| [ regex.singular.whereas ], |
| [ regex.singular.criterion ], |
| [ regex.singular.genus ], |
| |
| // original rule |
| [ regex.plural.men , '$1an' ], |
| [ regex.plural.people , '$1rson' ], |
| [ regex.plural.children , '$1' ], |
| [ regex.plural.genera , 'genus'], |
| [ regex.plural.criteria , '$1on'], |
| [ regex.plural.tia , '$1um' ], |
| [ regex.plural.analyses , '$1$2sis' ], |
| [ regex.plural.hives , '$1ve' ], |
| [ regex.plural.curves , '$1' ], |
| [ regex.plural.lrves , '$1f' ], |
| [ regex.plural.foves , '$1fe' ], |
| [ regex.plural.movies , '$1ovie' ], |
| [ regex.plural.aeiouyies, '$1y' ], |
| [ regex.plural.series , '$1eries' ], |
| [ regex.plural.xes , '$1' ], |
| [ regex.plural.mice , '$1ouse' ], |
| [ regex.plural.buses , '$1' ], |
| [ regex.plural.oes , '$1' ], |
| [ regex.plural.shoes , '$1' ], |
| [ regex.plural.crises , '$1is' ], |
| [ regex.plural.octopi , '$1us' ], |
| [ regex.plural.aliases , '$1' ], |
| [ regex.plural.summonses, '$1' ], |
| [ regex.plural.oxen , '$1' ], |
| [ regex.plural.matrices , '$1ix' ], |
| [ regex.plural.vertices , '$1ex' ], |
| [ regex.plural.feet , 'foot' ], |
| [ regex.plural.teeth , 'tooth' ], |
| [ regex.plural.geese , 'goose' ], |
| [ regex.plural.quizzes , '$1' ], |
| [ regex.plural.whereases, '$1' ], |
| |
| [ regex.plural.ss, 'ss' ], |
| [ regex.plural.s , '' ] |
| ]; |
| |
| /** |
| * @description This is a list of words that should not be capitalized for title case. |
| * @private |
| */ |
| var non_titlecased_words = [ |
| 'and', 'or', 'nor', 'a', 'an', 'the', 'so', 'but', 'to', 'of', 'at','by', |
| 'from', 'into', 'on', 'onto', 'off', 'out', 'in', 'over', 'with', 'for' |
| ]; |
| |
| /** |
| * @description These are regular expressions used for converting between String formats. |
| * @private |
| */ |
| var id_suffix = new RegExp( '(_ids|_id)$', 'g' ); |
| var underbar = new RegExp( '_', 'g' ); |
| var space_or_underbar = new RegExp( '[\ _]', 'g' ); |
| var uppercase = new RegExp( '([A-Z])', 'g' ); |
| var underbar_prefix = new RegExp( '^_' ); |
| |
| var inflector = { |
| |
| /** |
| * A helper method that applies rules based replacement to a String. |
| * @private |
| * @function |
| * @param {String} str String to modify and return based on the passed rules. |
| * @param {Array: [RegExp, String]} rules Regexp to match paired with String to use for replacement |
| * @param {Array: [String]} skip Strings to skip if they match |
| * @param {String} override String to return as though this method succeeded (used to conform to APIs) |
| * @returns {String} Return passed String modified by passed rules. |
| * @example |
| * |
| * this._apply_rules( 'cows', singular_rules ); // === 'cow' |
| */ |
| _apply_rules : function ( str, rules, skip, override ){ |
| if( override ){ |
| str = override; |
| }else{ |
| var ignore = ( inflector.indexOf( skip, str.toLowerCase()) > -1 ); |
| |
| if( !ignore ){ |
| var i = 0; |
| var j = rules.length; |
| |
| for( ; i < j; i++ ){ |
| if( str.match( rules[ i ][ 0 ])){ |
| if( rules[ i ][ 1 ] !== undefined ){ |
| str = str.replace( rules[ i ][ 0 ], rules[ i ][ 1 ]); |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| return str; |
| }, |
| |
| |
| |
| /** |
| * This lets us detect if an Array contains a given element. |
| * @public |
| * @function |
| * @param {Array} arr The subject array. |
| * @param {Object} item Object to locate in the Array. |
| * @param {Number} from_index Starts checking from this position in the Array.(optional) |
| * @param {Function} compare_func Function used to compare Array item vs passed item.(optional) |
| * @returns {Number} Return index position in the Array of the passed item. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.indexOf([ 'hi','there' ], 'guys' ); // === -1 |
| * inflection.indexOf([ 'hi','there' ], 'hi' ); // === 0 |
| */ |
| indexOf : function ( arr, item, from_index, compare_func ){ |
| if( !from_index ){ |
| from_index = -1; |
| } |
| |
| var index = -1; |
| var i = from_index; |
| var j = arr.length; |
| |
| for( ; i < j; i++ ){ |
| if( arr[ i ] === item || compare_func && compare_func( arr[ i ], item )){ |
| index = i; |
| break; |
| } |
| } |
| |
| return index; |
| }, |
| |
| |
| |
| /** |
| * This function adds pluralization support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @param {String} plural Overrides normal output with said String.(optional) |
| * @returns {String} Singular English language nouns are returned in plural form. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.pluralize( 'person' ); // === 'people' |
| * inflection.pluralize( 'octopus' ); // === 'octopi' |
| * inflection.pluralize( 'Hat' ); // === 'Hats' |
| * inflection.pluralize( 'person', 'guys' ); // === 'guys' |
| */ |
| pluralize : function ( str, plural ){ |
| return inflector._apply_rules( str, plural_rules, uncountable_words, plural ); |
| }, |
| |
| |
| |
| /** |
| * This function adds singularization support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @param {String} singular Overrides normal output with said String.(optional) |
| * @returns {String} Plural English language nouns are returned in singular form. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.singularize( 'people' ); // === 'person' |
| * inflection.singularize( 'octopi' ); // === 'octopus' |
| * inflection.singularize( 'Hats' ); // === 'Hat' |
| * inflection.singularize( 'guys', 'person' ); // === 'person' |
| */ |
| singularize : function ( str, singular ){ |
| return inflector._apply_rules( str, singular_rules, uncountable_words, singular ); |
| }, |
| |
| |
| /** |
| * This function will pluralize or singularlize a String appropriately based on an integer value |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @param {Number} count The number to base pluralization off of. |
| * @param {String} singular Overrides normal output with said String.(optional) |
| * @param {String} plural Overrides normal output with said String.(optional) |
| * @returns {String} English language nouns are returned in the plural or singular form based on the count. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.inflect( 'people' 1 ); // === 'person' |
| * inflection.inflect( 'octopi' 1 ); // === 'octopus' |
| * inflection.inflect( 'Hats' 1 ); // === 'Hat' |
| * inflection.inflect( 'guys', 1 , 'person' ); // === 'person' |
| * inflection.inflect( 'person', 2 ); // === 'people' |
| * inflection.inflect( 'octopus', 2 ); // === 'octopi' |
| * inflection.inflect( 'Hat', 2 ); // === 'Hats' |
| * inflection.inflect( 'person', 2, null, 'guys' ); // === 'guys' |
| */ |
| inflect : function ( str, count, singular, plural ){ |
| count = parseInt( count, 10 ); |
| |
| if( isNaN( count )) return str; |
| |
| if( count === 0 || count > 1 ){ |
| return inflector._apply_rules( str, plural_rules, uncountable_words, plural ); |
| }else{ |
| return inflector._apply_rules( str, singular_rules, uncountable_words, singular ); |
| } |
| }, |
| |
| |
| |
| /** |
| * This function adds camelization support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @param {Boolean} low_first_letter Default is to capitalize the first letter of the results.(optional) |
| * Passing true will lowercase it. |
| * @returns {String} Lower case underscored words will be returned in camel case. |
| * additionally '/' is translated to '::' |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.camelize( 'message_properties' ); // === 'MessageProperties' |
| * inflection.camelize( 'message_properties', true ); // === 'messageProperties' |
| */ |
| camelize : function ( str, low_first_letter ){ |
| var str_path = str.split( '/' ); |
| var i = 0; |
| var j = str_path.length; |
| var str_arr, init_x, k, l, first; |
| |
| for( ; i < j; i++ ){ |
| str_arr = str_path[ i ].split( '_' ); |
| k = 0; |
| l = str_arr.length; |
| |
| for( ; k < l; k++ ){ |
| if( k !== 0 ){ |
| str_arr[ k ] = str_arr[ k ].toLowerCase(); |
| } |
| |
| first = str_arr[ k ].charAt( 0 ); |
| first = low_first_letter && i === 0 && k === 0 |
| ? first.toLowerCase() : first.toUpperCase(); |
| str_arr[ k ] = first + str_arr[ k ].substring( 1 ); |
| } |
| |
| str_path[ i ] = str_arr.join( '' ); |
| } |
| |
| return str_path.join( '::' ); |
| }, |
| |
| |
| |
| /** |
| * This function adds underscore support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @param {Boolean} all_upper_case Default is to lowercase and add underscore prefix.(optional) |
| * Passing true will return as entered. |
| * @returns {String} Camel cased words are returned as lower cased and underscored. |
| * additionally '::' is translated to '/'. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.underscore( 'MessageProperties' ); // === 'message_properties' |
| * inflection.underscore( 'messageProperties' ); // === 'message_properties' |
| * inflection.underscore( 'MP', true ); // === 'MP' |
| */ |
| underscore : function ( str, all_upper_case ){ |
| if( all_upper_case && str === str.toUpperCase()) return str; |
| |
| var str_path = str.split( '::' ); |
| var i = 0; |
| var j = str_path.length; |
| |
| for( ; i < j; i++ ){ |
| str_path[ i ] = str_path[ i ].replace( uppercase, '_$1' ); |
| str_path[ i ] = str_path[ i ].replace( underbar_prefix, '' ); |
| } |
| |
| return str_path.join( '/' ).toLowerCase(); |
| }, |
| |
| |
| |
| /** |
| * This function adds humanize support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @param {Boolean} low_first_letter Default is to capitalize the first letter of the results.(optional) |
| * Passing true will lowercase it. |
| * @returns {String} Lower case underscored words will be returned in humanized form. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.humanize( 'message_properties' ); // === 'Message properties' |
| * inflection.humanize( 'message_properties', true ); // === 'message properties' |
| */ |
| humanize : function ( str, low_first_letter ){ |
| str = str.toLowerCase(); |
| str = str.replace( id_suffix, '' ); |
| str = str.replace( underbar, ' ' ); |
| |
| if( !low_first_letter ){ |
| str = inflector.capitalize( str ); |
| } |
| |
| return str; |
| }, |
| |
| |
| |
| /** |
| * This function adds capitalization support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @returns {String} All characters will be lower case and the first will be upper. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.capitalize( 'message_properties' ); // === 'Message_properties' |
| * inflection.capitalize( 'message properties', true ); // === 'Message properties' |
| */ |
| capitalize : function ( str ){ |
| str = str.toLowerCase(); |
| |
| return str.substring( 0, 1 ).toUpperCase() + str.substring( 1 ); |
| }, |
| |
| |
| |
| /** |
| * This function replaces underscores with dashes in the string. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @returns {String} Replaces all spaces or underscores with dashes. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.dasherize( 'message_properties' ); // === 'message-properties' |
| * inflection.dasherize( 'Message Properties' ); // === 'Message-Properties' |
| */ |
| dasherize : function ( str ){ |
| return str.replace( space_or_underbar, '-' ); |
| }, |
| |
| |
| |
| /** |
| * This function adds titleize support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @returns {String} Capitalizes words as you would for a book title. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.titleize( 'message_properties' ); // === 'Message Properties' |
| * inflection.titleize( 'message properties to keep' ); // === 'Message Properties to Keep' |
| */ |
| titleize : function ( str ){ |
| str = str.toLowerCase().replace( underbar, ' ' ); |
| var str_arr = str.split( ' ' ); |
| var i = 0; |
| var j = str_arr.length; |
| var d, k, l; |
| |
| for( ; i < j; i++ ){ |
| d = str_arr[ i ].split( '-' ); |
| k = 0; |
| l = d.length; |
| |
| for( ; k < l; k++){ |
| if( inflector.indexOf( non_titlecased_words, d[ k ].toLowerCase()) < 0 ){ |
| d[ k ] = inflector.capitalize( d[ k ]); |
| } |
| } |
| |
| str_arr[ i ] = d.join( '-' ); |
| } |
| |
| str = str_arr.join( ' ' ); |
| str = str.substring( 0, 1 ).toUpperCase() + str.substring( 1 ); |
| |
| return str; |
| }, |
| |
| |
| |
| /** |
| * This function adds demodulize support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @returns {String} Removes module names leaving only class names.(Ruby style) |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.demodulize( 'Message::Bus::Properties' ); // === 'Properties' |
| */ |
| demodulize : function ( str ){ |
| var str_arr = str.split( '::' ); |
| |
| return str_arr[ str_arr.length - 1 ]; |
| }, |
| |
| |
| |
| /** |
| * This function adds tableize support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @returns {String} Return camel cased words into their underscored plural form. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.tableize( 'MessageBusProperty' ); // === 'message_bus_properties' |
| */ |
| tableize : function ( str ){ |
| str = inflector.underscore( str ); |
| str = inflector.pluralize( str ); |
| |
| return str; |
| }, |
| |
| |
| |
| /** |
| * This function adds classification support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @returns {String} Underscored plural nouns become the camel cased singular form. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.classify( 'message_bus_properties' ); // === 'MessageBusProperty' |
| */ |
| classify : function ( str ){ |
| str = inflector.camelize( str ); |
| str = inflector.singularize( str ); |
| |
| return str; |
| }, |
| |
| |
| |
| /** |
| * This function adds foreign key support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @param {Boolean} drop_id_ubar Default is to seperate id with an underbar at the end of the class name, |
| you can pass true to skip it.(optional) |
| * @returns {String} Underscored plural nouns become the camel cased singular form. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.foreign_key( 'MessageBusProperty' ); // === 'message_bus_property_id' |
| * inflection.foreign_key( 'MessageBusProperty', true ); // === 'message_bus_propertyid' |
| */ |
| foreign_key : function ( str, drop_id_ubar ){ |
| str = inflector.demodulize( str ); |
| str = inflector.underscore( str ) + (( drop_id_ubar ) ? ( '' ) : ( '_' )) + 'id'; |
| |
| return str; |
| }, |
| |
| |
| |
| /** |
| * This function adds ordinalize support to every String object. |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @returns {String} Return all found numbers their sequence like '22nd'. |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.ordinalize( 'the 1 pitch' ); // === 'the 1st pitch' |
| */ |
| ordinalize : function ( str ){ |
| var str_arr = str.split( ' ' ); |
| var i = 0; |
| var j = str_arr.length; |
| |
| for( ; i < j; i++ ){ |
| var k = parseInt( str_arr[ i ], 10 ); |
| |
| if( !isNaN( k )){ |
| var ltd = str_arr[ i ].substring( str_arr[ i ].length - 2 ); |
| var ld = str_arr[ i ].substring( str_arr[ i ].length - 1 ); |
| var suf = 'th'; |
| |
| if( ltd != '11' && ltd != '12' && ltd != '13' ){ |
| if( ld === '1' ){ |
| suf = 'st'; |
| }else if( ld === '2' ){ |
| suf = 'nd'; |
| }else if( ld === '3' ){ |
| suf = 'rd'; |
| } |
| } |
| |
| str_arr[ i ] += suf; |
| } |
| } |
| |
| return str_arr.join( ' ' ); |
| }, |
| |
| /** |
| * This function performs multiple inflection methods on a string |
| * @public |
| * @function |
| * @param {String} str The subject string. |
| * @param {Array} arr An array of inflection methods. |
| * @returns {String} |
| * @example |
| * |
| * var inflection = require( 'inflection' ); |
| * |
| * inflection.transform( 'all job', [ 'pluralize', 'capitalize', 'dasherize' ]); // === 'All-jobs' |
| */ |
| transform : function ( str, arr ){ |
| var i = 0; |
| var j = arr.length; |
| |
| for( ;i < j; i++ ){ |
| var method = arr[ i ]; |
| |
| if( this.hasOwnProperty( method )){ |
| str = this[ method ]( str ); |
| } |
| } |
| |
| return str; |
| } |
| }; |
| |
| /** |
| * @public |
| */ |
| inflector.version = '1.10.0'; |
| |
| return inflector; |
| })); |
