underscore-inflections-rails 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,673 @@
1
+ // Underscore.string
2
+ // (c) 2010 Esa-Matti Suuronen <esa-matti aet suuronen dot org>
3
+ // Underscore.string is freely distributable under the terms of the MIT license.
4
+ // Documentation: https://github.com/epeli/underscore.string
5
+ // Some code is borrowed from MooTools and Alexandru Marasteanu.
6
+ // Version '2.3.2'
7
+
8
+ !function(root, String){
9
+ 'use strict';
10
+
11
+ // Defining helper functions.
12
+
13
+ var nativeTrim = String.prototype.trim;
14
+ var nativeTrimRight = String.prototype.trimRight;
15
+ var nativeTrimLeft = String.prototype.trimLeft;
16
+
17
+ var parseNumber = function(source) { return source * 1 || 0; };
18
+
19
+ var strRepeat = function(str, qty){
20
+ if (qty < 1) return '';
21
+ var result = '';
22
+ while (qty > 0) {
23
+ if (qty & 1) result += str;
24
+ qty >>= 1, str += str;
25
+ }
26
+ return result;
27
+ };
28
+
29
+ var slice = [].slice;
30
+
31
+ var defaultToWhiteSpace = function(characters) {
32
+ if (characters == null)
33
+ return '\\s';
34
+ else if (characters.source)
35
+ return characters.source;
36
+ else
37
+ return '[' + _s.escapeRegExp(characters) + ']';
38
+ };
39
+
40
+ // Helper for toBoolean
41
+ function boolMatch(s, matchers) {
42
+ var i, matcher, down = s.toLowerCase();
43
+ matchers = [].concat(matchers);
44
+ for (i = 0; i < matchers.length; i += 1) {
45
+ matcher = matchers[i];
46
+ if (!matcher) continue;
47
+ if (matcher.test && matcher.test(s)) return true;
48
+ if (matcher.toLowerCase() === down) return true;
49
+ }
50
+ }
51
+
52
+ var escapeChars = {
53
+ lt: '<',
54
+ gt: '>',
55
+ quot: '"',
56
+ amp: '&',
57
+ apos: "'"
58
+ };
59
+
60
+ var reversedEscapeChars = {};
61
+ for(var key in escapeChars) reversedEscapeChars[escapeChars[key]] = key;
62
+ reversedEscapeChars["'"] = '#39';
63
+
64
+ // sprintf() for JavaScript 0.7-beta1
65
+ // http://www.diveintojavascript.com/projects/javascript-sprintf
66
+ //
67
+ // Copyright (c) Alexandru Marasteanu <alexaholic [at) gmail (dot] com>
68
+ // All rights reserved.
69
+
70
+ var sprintf = (function() {
71
+ function get_type(variable) {
72
+ return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();
73
+ }
74
+
75
+ var str_repeat = strRepeat;
76
+
77
+ var str_format = function() {
78
+ if (!str_format.cache.hasOwnProperty(arguments[0])) {
79
+ str_format.cache[arguments[0]] = str_format.parse(arguments[0]);
80
+ }
81
+ return str_format.format.call(null, str_format.cache[arguments[0]], arguments);
82
+ };
83
+
84
+ str_format.format = function(parse_tree, argv) {
85
+ var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length;
86
+ for (i = 0; i < tree_length; i++) {
87
+ node_type = get_type(parse_tree[i]);
88
+ if (node_type === 'string') {
89
+ output.push(parse_tree[i]);
90
+ }
91
+ else if (node_type === 'array') {
92
+ match = parse_tree[i]; // convenience purposes only
93
+ if (match[2]) { // keyword argument
94
+ arg = argv[cursor];
95
+ for (k = 0; k < match[2].length; k++) {
96
+ if (!arg.hasOwnProperty(match[2][k])) {
97
+ throw new Error(sprintf('[_.sprintf] property "%s" does not exist', match[2][k]));
98
+ }
99
+ arg = arg[match[2][k]];
100
+ }
101
+ } else if (match[1]) { // positional argument (explicit)
102
+ arg = argv[match[1]];
103
+ }
104
+ else { // positional argument (implicit)
105
+ arg = argv[cursor++];
106
+ }
107
+
108
+ if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) {
109
+ throw new Error(sprintf('[_.sprintf] expecting number but found %s', get_type(arg)));
110
+ }
111
+ switch (match[8]) {
112
+ case 'b': arg = arg.toString(2); break;
113
+ case 'c': arg = String.fromCharCode(arg); break;
114
+ case 'd': arg = parseInt(arg, 10); break;
115
+ case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break;
116
+ case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break;
117
+ case 'o': arg = arg.toString(8); break;
118
+ case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break;
119
+ case 'u': arg = Math.abs(arg); break;
120
+ case 'x': arg = arg.toString(16); break;
121
+ case 'X': arg = arg.toString(16).toUpperCase(); break;
122
+ }
123
+ arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg);
124
+ pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' ';
125
+ pad_length = match[6] - String(arg).length;
126
+ pad = match[6] ? str_repeat(pad_character, pad_length) : '';
127
+ output.push(match[5] ? arg + pad : pad + arg);
128
+ }
129
+ }
130
+ return output.join('');
131
+ };
132
+
133
+ str_format.cache = {};
134
+
135
+ str_format.parse = function(fmt) {
136
+ var _fmt = fmt, match = [], parse_tree = [], arg_names = 0;
137
+ while (_fmt) {
138
+ if ((match = /^[^\x25]+/.exec(_fmt)) !== null) {
139
+ parse_tree.push(match[0]);
140
+ }
141
+ else if ((match = /^\x25{2}/.exec(_fmt)) !== null) {
142
+ parse_tree.push('%');
143
+ }
144
+ else if ((match = /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(_fmt)) !== null) {
145
+ if (match[2]) {
146
+ arg_names |= 1;
147
+ var field_list = [], replacement_field = match[2], field_match = [];
148
+ if ((field_match = /^([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
149
+ field_list.push(field_match[1]);
150
+ while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
151
+ if ((field_match = /^\.([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
152
+ field_list.push(field_match[1]);
153
+ }
154
+ else if ((field_match = /^\[(\d+)\]/.exec(replacement_field)) !== null) {
155
+ field_list.push(field_match[1]);
156
+ }
157
+ else {
158
+ throw new Error('[_.sprintf] huh?');
159
+ }
160
+ }
161
+ }
162
+ else {
163
+ throw new Error('[_.sprintf] huh?');
164
+ }
165
+ match[2] = field_list;
166
+ }
167
+ else {
168
+ arg_names |= 2;
169
+ }
170
+ if (arg_names === 3) {
171
+ throw new Error('[_.sprintf] mixing positional and named placeholders is not (yet) supported');
172
+ }
173
+ parse_tree.push(match);
174
+ }
175
+ else {
176
+ throw new Error('[_.sprintf] huh?');
177
+ }
178
+ _fmt = _fmt.substring(match[0].length);
179
+ }
180
+ return parse_tree;
181
+ };
182
+
183
+ return str_format;
184
+ })();
185
+
186
+
187
+
188
+ // Defining underscore.string
189
+
190
+ var _s = {
191
+
192
+ VERSION: '2.3.0',
193
+
194
+ isBlank: function(str){
195
+ if (str == null) str = '';
196
+ return (/^\s*$/).test(str);
197
+ },
198
+
199
+ stripTags: function(str){
200
+ if (str == null) return '';
201
+ return String(str).replace(/<\/?[^>]+>/g, '');
202
+ },
203
+
204
+ capitalize : function(str){
205
+ str = str == null ? '' : String(str);
206
+ return str.charAt(0).toUpperCase() + str.slice(1);
207
+ },
208
+
209
+ chop: function(str, step){
210
+ if (str == null) return [];
211
+ str = String(str);
212
+ step = ~~step;
213
+ return step > 0 ? str.match(new RegExp('.{1,' + step + '}', 'g')) : [str];
214
+ },
215
+
216
+ clean: function(str){
217
+ return _s.strip(str).replace(/\s+/g, ' ');
218
+ },
219
+
220
+ count: function(str, substr){
221
+ if (str == null || substr == null) return 0;
222
+
223
+ str = String(str);
224
+ substr = String(substr);
225
+
226
+ var count = 0,
227
+ pos = 0,
228
+ length = substr.length;
229
+
230
+ while (true) {
231
+ pos = str.indexOf(substr, pos);
232
+ if (pos === -1) break;
233
+ count++;
234
+ pos += length;
235
+ }
236
+
237
+ return count;
238
+ },
239
+
240
+ chars: function(str) {
241
+ if (str == null) return [];
242
+ return String(str).split('');
243
+ },
244
+
245
+ swapCase: function(str) {
246
+ if (str == null) return '';
247
+ return String(str).replace(/\S/g, function(c){
248
+ return c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase();
249
+ });
250
+ },
251
+
252
+ escapeHTML: function(str) {
253
+ if (str == null) return '';
254
+ return String(str).replace(/[&<>"']/g, function(m){ return '&' + reversedEscapeChars[m] + ';'; });
255
+ },
256
+
257
+ unescapeHTML: function(str) {
258
+ if (str == null) return '';
259
+ return String(str).replace(/\&([^;]+);/g, function(entity, entityCode){
260
+ var match;
261
+
262
+ if (entityCode in escapeChars) {
263
+ return escapeChars[entityCode];
264
+ } else if (match = entityCode.match(/^#x([\da-fA-F]+)$/)) {
265
+ return String.fromCharCode(parseInt(match[1], 16));
266
+ } else if (match = entityCode.match(/^#(\d+)$/)) {
267
+ return String.fromCharCode(~~match[1]);
268
+ } else {
269
+ return entity;
270
+ }
271
+ });
272
+ },
273
+
274
+ escapeRegExp: function(str){
275
+ if (str == null) return '';
276
+ return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
277
+ },
278
+
279
+ splice: function(str, i, howmany, substr){
280
+ var arr = _s.chars(str);
281
+ arr.splice(~~i, ~~howmany, substr);
282
+ return arr.join('');
283
+ },
284
+
285
+ insert: function(str, i, substr){
286
+ return _s.splice(str, i, 0, substr);
287
+ },
288
+
289
+ include: function(str, needle){
290
+ if (needle === '') return true;
291
+ if (str == null) return false;
292
+ return String(str).indexOf(needle) !== -1;
293
+ },
294
+
295
+ join: function() {
296
+ var args = slice.call(arguments),
297
+ separator = args.shift();
298
+
299
+ if (separator == null) separator = '';
300
+
301
+ return args.join(separator);
302
+ },
303
+
304
+ lines: function(str) {
305
+ if (str == null) return [];
306
+ return String(str).split("\n");
307
+ },
308
+
309
+ reverse: function(str){
310
+ return _s.chars(str).reverse().join('');
311
+ },
312
+
313
+ startsWith: function(str, starts){
314
+ if (starts === '') return true;
315
+ if (str == null || starts == null) return false;
316
+ str = String(str); starts = String(starts);
317
+ return str.length >= starts.length && str.slice(0, starts.length) === starts;
318
+ },
319
+
320
+ endsWith: function(str, ends){
321
+ if (ends === '') return true;
322
+ if (str == null || ends == null) return false;
323
+ str = String(str); ends = String(ends);
324
+ return str.length >= ends.length && str.slice(str.length - ends.length) === ends;
325
+ },
326
+
327
+ succ: function(str){
328
+ if (str == null) return '';
329
+ str = String(str);
330
+ return str.slice(0, -1) + String.fromCharCode(str.charCodeAt(str.length-1) + 1);
331
+ },
332
+
333
+ titleize: function(str){
334
+ if (str == null) return '';
335
+ str = String(str).toLowerCase();
336
+ return str.replace(/(?:^|\s|-)\S/g, function(c){ return c.toUpperCase(); });
337
+ },
338
+
339
+ camelize: function(str){
340
+ return _s.trim(str).replace(/[-_\s]+(.)?/g, function(match, c){ return c ? c.toUpperCase() : ""; });
341
+ },
342
+
343
+ underscored: function(str){
344
+ return _s.trim(str).replace(/([a-z\d])([A-Z]+)/g, '$1_$2').replace(/[-\s]+/g, '_').toLowerCase();
345
+ },
346
+
347
+ dasherize: function(str){
348
+ return _s.trim(str).replace(/([A-Z])/g, '-$1').replace(/[-_\s]+/g, '-').toLowerCase();
349
+ },
350
+
351
+ classify: function(str){
352
+ return _s.titleize(String(str).replace(/[\W_]/g, ' ')).replace(/\s/g, '');
353
+ },
354
+
355
+ humanize: function(str){
356
+ return _s.capitalize(_s.underscored(str).replace(/_id$/,'').replace(/_/g, ' '));
357
+ },
358
+
359
+ trim: function(str, characters){
360
+ if (str == null) return '';
361
+ if (!characters && nativeTrim) return nativeTrim.call(str);
362
+ characters = defaultToWhiteSpace(characters);
363
+ return String(str).replace(new RegExp('\^' + characters + '+|' + characters + '+$', 'g'), '');
364
+ },
365
+
366
+ ltrim: function(str, characters){
367
+ if (str == null) return '';
368
+ if (!characters && nativeTrimLeft) return nativeTrimLeft.call(str);
369
+ characters = defaultToWhiteSpace(characters);
370
+ return String(str).replace(new RegExp('^' + characters + '+'), '');
371
+ },
372
+
373
+ rtrim: function(str, characters){
374
+ if (str == null) return '';
375
+ if (!characters && nativeTrimRight) return nativeTrimRight.call(str);
376
+ characters = defaultToWhiteSpace(characters);
377
+ return String(str).replace(new RegExp(characters + '+$'), '');
378
+ },
379
+
380
+ truncate: function(str, length, truncateStr){
381
+ if (str == null) return '';
382
+ str = String(str); truncateStr = truncateStr || '...';
383
+ length = ~~length;
384
+ return str.length > length ? str.slice(0, length) + truncateStr : str;
385
+ },
386
+
387
+ /**
388
+ * _s.prune: a more elegant version of truncate
389
+ * prune extra chars, never leaving a half-chopped word.
390
+ * @author github.com/rwz
391
+ */
392
+ prune: function(str, length, pruneStr){
393
+ if (str == null) return '';
394
+
395
+ str = String(str); length = ~~length;
396
+ pruneStr = pruneStr != null ? String(pruneStr) : '...';
397
+
398
+ if (str.length <= length) return str;
399
+
400
+ var tmpl = function(c){ return c.toUpperCase() !== c.toLowerCase() ? 'A' : ' '; },
401
+ template = str.slice(0, length+1).replace(/.(?=\W*\w*$)/g, tmpl); // 'Hello, world' -> 'HellAA AAAAA'
402
+
403
+ if (template.slice(template.length-2).match(/\w\w/))
404
+ template = template.replace(/\s*\S+$/, '');
405
+ else
406
+ template = _s.rtrim(template.slice(0, template.length-1));
407
+
408
+ return (template+pruneStr).length > str.length ? str : str.slice(0, template.length)+pruneStr;
409
+ },
410
+
411
+ words: function(str, delimiter) {
412
+ if (_s.isBlank(str)) return [];
413
+ return _s.trim(str, delimiter).split(delimiter || /\s+/);
414
+ },
415
+
416
+ pad: function(str, length, padStr, type) {
417
+ str = str == null ? '' : String(str);
418
+ length = ~~length;
419
+
420
+ var padlen = 0;
421
+
422
+ if (!padStr)
423
+ padStr = ' ';
424
+ else if (padStr.length > 1)
425
+ padStr = padStr.charAt(0);
426
+
427
+ switch(type) {
428
+ case 'right':
429
+ padlen = length - str.length;
430
+ return str + strRepeat(padStr, padlen);
431
+ case 'both':
432
+ padlen = length - str.length;
433
+ return strRepeat(padStr, Math.ceil(padlen/2)) + str
434
+ + strRepeat(padStr, Math.floor(padlen/2));
435
+ default: // 'left'
436
+ padlen = length - str.length;
437
+ return strRepeat(padStr, padlen) + str;
438
+ }
439
+ },
440
+
441
+ lpad: function(str, length, padStr) {
442
+ return _s.pad(str, length, padStr);
443
+ },
444
+
445
+ rpad: function(str, length, padStr) {
446
+ return _s.pad(str, length, padStr, 'right');
447
+ },
448
+
449
+ lrpad: function(str, length, padStr) {
450
+ return _s.pad(str, length, padStr, 'both');
451
+ },
452
+
453
+ sprintf: sprintf,
454
+
455
+ vsprintf: function(fmt, argv){
456
+ argv.unshift(fmt);
457
+ return sprintf.apply(null, argv);
458
+ },
459
+
460
+ toNumber: function(str, decimals) {
461
+ if (!str) return 0;
462
+ str = _s.trim(str);
463
+ if (!str.match(/^-?\d+(?:\.\d+)?$/)) return NaN;
464
+ return parseNumber(parseNumber(str).toFixed(~~decimals));
465
+ },
466
+
467
+ numberFormat : function(number, dec, dsep, tsep) {
468
+ if (isNaN(number) || number == null) return '';
469
+
470
+ number = number.toFixed(~~dec);
471
+ tsep = typeof tsep == 'string' ? tsep : ',';
472
+
473
+ var parts = number.split('.'), fnums = parts[0],
474
+ decimals = parts[1] ? (dsep || '.') + parts[1] : '';
475
+
476
+ return fnums.replace(/(\d)(?=(?:\d{3})+$)/g, '$1' + tsep) + decimals;
477
+ },
478
+
479
+ strRight: function(str, sep){
480
+ if (str == null) return '';
481
+ str = String(str); sep = sep != null ? String(sep) : sep;
482
+ var pos = !sep ? -1 : str.indexOf(sep);
483
+ return ~pos ? str.slice(pos+sep.length, str.length) : str;
484
+ },
485
+
486
+ strRightBack: function(str, sep){
487
+ if (str == null) return '';
488
+ str = String(str); sep = sep != null ? String(sep) : sep;
489
+ var pos = !sep ? -1 : str.lastIndexOf(sep);
490
+ return ~pos ? str.slice(pos+sep.length, str.length) : str;
491
+ },
492
+
493
+ strLeft: function(str, sep){
494
+ if (str == null) return '';
495
+ str = String(str); sep = sep != null ? String(sep) : sep;
496
+ var pos = !sep ? -1 : str.indexOf(sep);
497
+ return ~pos ? str.slice(0, pos) : str;
498
+ },
499
+
500
+ strLeftBack: function(str, sep){
501
+ if (str == null) return '';
502
+ str += ''; sep = sep != null ? ''+sep : sep;
503
+ var pos = str.lastIndexOf(sep);
504
+ return ~pos ? str.slice(0, pos) : str;
505
+ },
506
+
507
+ toSentence: function(array, separator, lastSeparator, serial) {
508
+ separator = separator || ', ';
509
+ lastSeparator = lastSeparator || ' and ';
510
+ var a = array.slice(), lastMember = a.pop();
511
+
512
+ if (array.length > 2 && serial) lastSeparator = _s.rtrim(separator) + lastSeparator;
513
+
514
+ return a.length ? a.join(separator) + lastSeparator + lastMember : lastMember;
515
+ },
516
+
517
+ toSentenceSerial: function() {
518
+ var args = slice.call(arguments);
519
+ args[3] = true;
520
+ return _s.toSentence.apply(_s, args);
521
+ },
522
+
523
+ slugify: function(str) {
524
+ if (str == null) return '';
525
+
526
+ var from = "ąàáäâãåæăćęèéëêìíïîłńòóöôõøśșțùúüûñçżź",
527
+ to = "aaaaaaaaaceeeeeiiiilnoooooosstuuuunczz",
528
+ regex = new RegExp(defaultToWhiteSpace(from), 'g');
529
+
530
+ str = String(str).toLowerCase().replace(regex, function(c){
531
+ var index = from.indexOf(c);
532
+ return to.charAt(index) || '-';
533
+ });
534
+
535
+ return _s.dasherize(str.replace(/[^\w\s-]/g, ''));
536
+ },
537
+
538
+ surround: function(str, wrapper) {
539
+ return [wrapper, str, wrapper].join('');
540
+ },
541
+
542
+ quote: function(str, quoteChar) {
543
+ return _s.surround(str, quoteChar || '"');
544
+ },
545
+
546
+ unquote: function(str, quoteChar) {
547
+ quoteChar = quoteChar || '"';
548
+ if (str[0] === quoteChar && str[str.length-1] === quoteChar)
549
+ return str.slice(1,str.length-1);
550
+ else return str;
551
+ },
552
+
553
+ exports: function() {
554
+ var result = {};
555
+
556
+ for (var prop in this) {
557
+ if (!this.hasOwnProperty(prop) || prop.match(/^(?:include|contains|reverse)$/)) continue;
558
+ result[prop] = this[prop];
559
+ }
560
+
561
+ return result;
562
+ },
563
+
564
+ repeat: function(str, qty, separator){
565
+ if (str == null) return '';
566
+
567
+ qty = ~~qty;
568
+
569
+ // using faster implementation if separator is not needed;
570
+ if (separator == null) return strRepeat(String(str), qty);
571
+
572
+ // this one is about 300x slower in Google Chrome
573
+ for (var repeat = []; qty > 0; repeat[--qty] = str) {}
574
+ return repeat.join(separator);
575
+ },
576
+
577
+ naturalCmp: function(str1, str2){
578
+ if (str1 == str2) return 0;
579
+ if (!str1) return -1;
580
+ if (!str2) return 1;
581
+
582
+ var cmpRegex = /(\.\d+)|(\d+)|(\D+)/g,
583
+ tokens1 = String(str1).toLowerCase().match(cmpRegex),
584
+ tokens2 = String(str2).toLowerCase().match(cmpRegex),
585
+ count = Math.min(tokens1.length, tokens2.length);
586
+
587
+ for(var i = 0; i < count; i++) {
588
+ var a = tokens1[i], b = tokens2[i];
589
+
590
+ if (a !== b){
591
+ var num1 = parseInt(a, 10);
592
+ if (!isNaN(num1)){
593
+ var num2 = parseInt(b, 10);
594
+ if (!isNaN(num2) && num1 - num2)
595
+ return num1 - num2;
596
+ }
597
+ return a < b ? -1 : 1;
598
+ }
599
+ }
600
+
601
+ if (tokens1.length === tokens2.length)
602
+ return tokens1.length - tokens2.length;
603
+
604
+ return str1 < str2 ? -1 : 1;
605
+ },
606
+
607
+ levenshtein: function(str1, str2) {
608
+ if (str1 == null && str2 == null) return 0;
609
+ if (str1 == null) return String(str2).length;
610
+ if (str2 == null) return String(str1).length;
611
+
612
+ str1 = String(str1); str2 = String(str2);
613
+
614
+ var current = [], prev, value;
615
+
616
+ for (var i = 0; i <= str2.length; i++)
617
+ for (var j = 0; j <= str1.length; j++) {
618
+ if (i && j)
619
+ if (str1.charAt(j - 1) === str2.charAt(i - 1))
620
+ value = prev;
621
+ else
622
+ value = Math.min(current[j], current[j - 1], prev) + 1;
623
+ else
624
+ value = i + j;
625
+
626
+ prev = current[j];
627
+ current[j] = value;
628
+ }
629
+
630
+ return current.pop();
631
+ },
632
+
633
+ toBoolean: function(str, trueValues, falseValues) {
634
+ if (typeof str === "number") str = "" + str;
635
+ if (typeof str !== "string") return !!str;
636
+ str = _s.trim(str);
637
+ if (boolMatch(str, trueValues || ["true", "1"])) return true;
638
+ if (boolMatch(str, falseValues || ["false", "0"])) return false;
639
+ }
640
+ };
641
+
642
+ // Aliases
643
+
644
+ _s.strip = _s.trim;
645
+ _s.lstrip = _s.ltrim;
646
+ _s.rstrip = _s.rtrim;
647
+ _s.center = _s.lrpad;
648
+ _s.rjust = _s.lpad;
649
+ _s.ljust = _s.rpad;
650
+ _s.contains = _s.include;
651
+ _s.q = _s.quote;
652
+ _s.toBool = _s.toBoolean;
653
+
654
+ // Exporting
655
+
656
+ // CommonJS module is defined
657
+ if (typeof exports !== 'undefined') {
658
+ if (typeof module !== 'undefined' && module.exports)
659
+ module.exports = _s;
660
+
661
+ exports._s = _s;
662
+ }
663
+
664
+ // Register as a named module with AMD.
665
+ if (typeof define === 'function' && define.amd)
666
+ define('underscore.string', [], function(){ return _s; });
667
+
668
+
669
+ // Integrate with Underscore.js if defined
670
+ // or create our own underscore object.
671
+ root._ = root._ || {};
672
+ root._.string = root._.str = _s;
673
+ }(this, String);