nightfury7 / universalbasics.js

src/ub.strings.case.js

/** global: UB */

// CASING

// PROVIDES THE TABLES USED FOR FAST CASE-INSENSITIVE STRING COMPARISON
// FOR THESE TABLES SEE "unicode uppercase lowercase tables.xlsx"

// meta tables
UB.UTF_casingRangedLowerS = [97, 224, 1072, 1121, 1169, 1377, 4304, 7681, 7841, 9424];
UB.UTF_casingRangedLowerE = [122, 246, 1103, 1153, 1215, 1414, 4341, 7829, 7929, 9449];
UB.UTF_casingRangedIncrement = [1, 1, 1, 2, 2, 1, 1, 2, 2, 1];
UB.UTF_casingRangedUpper = [65, 192, 1040, 1120, 1168, 1329, 4256, 7680, 7840, 9398];

// raw tables
UB.UTF_casingRawLower = [248, 249, 250, 251, 252, 253, 254, 255, 257, 259, 261, 263, 265, 267, 269, 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, 291, 293, 295, 297, 299, 301, 303, 305, 307, 309, 311, 314, 316, 318, 320, 322, 324, 326, 328, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349, 351, 353, 355, 357, 359, 361, 363, 365, 367, 369, 371, 373, 375, 378, 380, 382, 387, 389, 392, 396, 402, 409, 417, 419, 421, 424, 429, 432, 436, 438, 441, 445, 454, 457, 460, 462, 464, 466, 468, 470, 472, 474, 476, 479, 481, 483, 485, 487, 489, 491, 493, 495, 499, 501, 507, 509, 511, 513, 515, 517, 519, 521, 523, 525, 527, 529, 531, 533, 535, 595, 596, 599, 600, 601, 603, 608, 611, 616, 617, 623, 626, 629, 643, 648, 650, 651, 658, 940, 941, 942, 943, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 995, 997, 999, 1001, 1003, 1005, 1007, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1118, 1119, 1218, 1220, 1224, 1228, 1233, 1235, 1237, 1239, 1241, 1243, 1245, 1247, 1249, 1251, 1253, 1255, 1257, 1259, 1263, 1265, 1267, 1269, 1273, 7936, 7937, 7938, 7939, 7940, 7941, 7942, 7943, 7952, 7953, 7954, 7955, 7956, 7957, 7968, 7969, 7970, 7971, 7972, 7973, 7974, 7975, 7984, 7985, 7986, 7987, 7988, 7989, 7990, 7991, 8000, 8001, 8002, 8003, 8004, 8005, 8017, 8019, 8021, 8023, 8032, 8033, 8034, 8035, 8036, 8037, 8038, 8039, 8064, 8065, 8066, 8067, 8068, 8069, 8070, 8071, 8080, 8081, 8082, 8083, 8084, 8085, 8086, 8087, 8096, 8097, 8098, 8099, 8100, 8101, 8102, 8103, 8112, 8113, 8144, 8145, 8160, 8161];
UB.UTF_casingRawUpper = [216, 217, 218, 219, 220, 221, 222, 376, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 73, 306, 308, 310, 313, 315, 317, 319, 321, 323, 325, 327, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 377, 379, 381, 386, 388, 391, 395, 401, 408, 416, 418, 420, 423, 428, 431, 435, 437, 440, 444, 452, 455, 458, 461, 463, 465, 467, 469, 471, 473, 475, 478, 480, 482, 484, 486, 488, 490, 492, 494, 497, 500, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 385, 390, 394, 398, 399, 400, 403, 404, 407, 406, 412, 413, 415, 425, 430, 433, 434, 439, 902, 904, 905, 906, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 931, 932, 933, 934, 935, 936, 937, 938, 939, 908, 910, 911, 994, 996, 998, 1000, 1002, 1004, 1006, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1038, 1039, 1217, 1219, 1223, 1227, 1232, 1234, 1236, 1238, 1240, 1242, 1244, 1246, 1248, 1250, 1252, 1254, 1256, 1258, 1262, 1264, 1266, 1268, 1272, 7944, 7945, 7946, 7947, 7948, 7949, 7950, 7951, 7960, 7961, 7962, 7963, 7964, 7965, 7976, 7977, 7978, 7979, 7980, 7981, 7982, 7983, 7992, 7993, 7994, 7995, 7996, 7997, 7998, 7999, 8008, 8009, 8010, 8011, 8012, 8013, 8025, 8027, 8029, 8031, 8040, 8041, 8042, 8043, 8044, 8045, 8046, 8047, 8072, 8073, 8074, 8075, 8076, 8077, 8078, 8079, 8088, 8089, 8090, 8091, 8092, 8093, 8094, 8095, 8104, 8105, 8106, 8107, 8108, 8109, 8110, 8111, 8120, 8121, 8152, 8153, 8168, 8169];


// final tables (= ranged + raw)
UB.UTF_casingTablesMax = 9450;

UB.initCasing = function(){
	
	// exit if already initialized
	if (UB.UTF_lowerToUpper != null){
		return;
	}
	
	// CALC CASING CONVERSION TABLES
	UB.UTF_lowerToUpper = [];
	UB.UTF_upperToLower = [];
	
	// init by mapping to self (most chars dont have an uppercase/lowercase version)
	for (var n = 0, nlast = UB.UTF_casingTablesMax;n <= nlast;n++){
		UB.UTF_lowerToUpper[n] = n;
		UB.UTF_upperToLower[n] = n;
	}
	
	// per range
	for (var r = 0, rl = UB.UTF_casingRangedLowerS.length;r<rl;r++){
		
		// per value in range
		var inc = UB.UTF_casingRangedIncrement[r];
		var offset = UB.UTF_casingRangedUpper[r] - UB.UTF_casingRangedLowerS[r];
		for (var lower = UB.UTF_casingRangedLowerS[r], lowerlast = UB.UTF_casingRangedLowerE[r];lower <= lowerlast;lower += inc){
			
			// calc uppercase
			var upper = lower + offset;
			
			// store in table
			UB.UTF_lowerToUpper[lower] = upper;
			UB.UTF_upperToLower[upper] = lower;
			
		}
		
	}
	
	// per raw value
	for (var n = 0, nl = UB.UTF_casingRawLower.length;n<nl;n++){

The variable n already seems to be declared on line 34. Consider using another variable name or omitting the var keyword.

		
		lower = UB.UTF_casingRawLower[n];
		upper = UB.UTF_casingRawUpper[n];
		
		// store in table
		UB.UTF_lowerToUpper[lower] = upper;
		UB.UTF_upperToLower[upper] = lower;
		
	}
	
	// fix bug in unicode table .. "I" >> "i"
	UB.UTF_upperToLower[73] = 105;
	
	
}


var arrayFuncs = {

	camelCaseMergeWords: function(firstCharCaps = false){
		var words = this;
		
		// lowercase first letter
		words[0] = firstCharCaps ? words[0].uppercaseFirst() : words[0].lowercaseFirst();
		
		// loop thru all words
		var newWords = "";
		for (var w = 0, wl = words.length;w<wl;w++){
			var word = words[w].replace(UB.regex.Trim, '');
			
			// cap first letter if not 1st word
			newWords += w === 0 ? word : word.uppercaseFirst();
		}
		return newWords;
	},
	
	none:null
};

// register funcs
UB.registerFuncs(Array.prototype, arrayFuncs);


var stringFuncs = {
	
	// casing
	camelCaseSeperate: function(){
		var camelCase = this;
		
		// loop thru all chars
		var lastUp = false;
		var lastSpace = false;
		var newName = [];
		var len = 0;
		for (var c = 0, cl = camelCase.length - 1;c <= cl;c++){
			var char = camelCase.charAt(c);
			var charNext = c < cl ? camelCase.charAt(c + 1) : "_";
			
			// if its a Capital ... and if prev is not also a capital ... or if the next is small
			var up = (char.toUpperCase() == char);
			var nextUp = (charNext.toUpperCase() == charNext);
			if ((up && (!lastUp || !nextUp) && !lastSpace) || char == "_") {
				
				// add a space
				if (len > 0 && newName[len - 1] != " "){
					newName.push(" ");
					len++;
				}
			}
			lastUp = up;
			
			// add the char
			if (char != "_"){
				newName.push(char);
				len++;
			}
			lastSpace = char == " ";
		}
		
		// caps first letter
		return newName.join("").uppercaseFirst();
	},
	camelCaseSeperateWords: function(){
		var camelCase = this;
		return camelCase.camelCaseSeperate().split(" ");
	},
	camelCaseMerge: function(firstCharCaps = false){
		var sentence = this;
		
		// exit quickly if no spaces .. no words to merge
		if (sentence.indexOf(" ") === -1) {
			if (firstCharCaps) {
				return sentence.uppercaseFirst();
			}
			return sentence;
		}
		
		// merge words using camel case
		return sentence.split(" ").camelCaseMergeWords(firstCharCaps);
	},
	uppercaseFirst: function(){
		var str = this;
		str = str.trim();
		return str.charAt(0).toUpperCase() + str.substr(1);
	},
	lowercaseFirst: function(){
		var str = this;
		str = str.trim();
		return str.charAt(0).toLowerCase() + str.substr(1);
	},
	toSmartCase: function(){
		var word = this;
		return word.toCustomCase(";,. -_" + "\t" + "\n", true);
	},
	toSentenceCase: function(){
		var word = this;
		return word.toCustomCase(".", false);
	},
	toCustomCase: function(capsAfterChars, preserveCaps = false){
		var word = this;
		var nextCaps = true;// first char caps
		
		// per char
		var chars = word.splitChars();
		var chars2 = [];
		for (var c = 0, cl = chars.length;c<cl;c++){
			var ch = chars[c];
			var added = false;
			
			// add as CAPS if wanted
			if (nextCaps) {
				nextCaps = false;
				chars2.push(ch.toUpperCase());
				added = true;
			}
			
			// next char should have caps
			if (capsAfterChars.indexOf(ch) > -1) {
				nextCaps = true;
			}
			
			// add normally
			if (!added) {
				
				// preserve caps if wanted
				if (preserveCaps && ch.toUpperCase() == ch) {
					chars2.push(ch);
				}else {
					
					// add as lower case
					chars2.push(ch.toLowerCase());
				}
			}
		}
		return chars2.join("");
	},
	toTitleCase: function(){
		var word = this;
		return word.toCustomCase(";,. -_" + "\t" + "\n", false);
	},
	toSentenceTitleCase: function(){
		var title = this;
		var parts = [];
		var index = 0;
		
		// create regexps
		var small = "(a|an|and|as|at|but|by|en|for|if|in|of|on|or|the|to|v[.]?|via|vs[.]?)";
		var punct = "([!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]*)";
		var r1 =  new RegExp("\\b([A-Za-z][a-z.'Õ]*)\\b", "g");
		var r2 =  new RegExp("[A-Za-z]\\.[A-Za-z]", "");
		var r3 =  new RegExp("\\b" + small + "\\b", "ig");
		var r4 =  new RegExp("^" + punct + small + "\\b", "ig");
		var r5 =  new RegExp("\\b" + small + punct + "$", "ig");
		var r6 =  new RegExp(" V(s?)\\. ", "ig");
		var r7 =  new RegExp("(['Õ])S\\b", "ig");
		var split =  new RegExp("[:.;?!] |(?: |^)[\"Ò]", "g");
		
		// per word in string
		while (true) {
			var m = split.exec(title);
			
			var ToLowerCase = function(x){
				return x.toLowerCase();
			}
			var ToUpperCaseFirst = function(x){
				return x.uppercaseFirst();
			}

			// smart capatalize
			parts.push( title.substring(index, m ? m.index : title.length).replace(r1, function(all) {
				return r2.test(all) ? all : all.uppercaseFirst();
			}).replace(r3, ToLowerCase).replace(r4, function (all, punct, word){
				return punct + word.uppercaseFirst();
			}).replace(r5, ToUpperCaseFirst));
			
			index = split.lastIndex;
			
			if ( m ) parts.push( m[0] );

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

			else break;
		}
		
		return parts.join("").replace(r6, " v$1. ").replace(r7, "$1s");
	},
	toCamelCase: function(){
		var word = this;
		return word.camelCaseMerge(false);
	},
	toPascalCase: function(){
		var word = this;
		return word.camelCaseMerge(true);
	},
	toURLCase: function(){
		var path = this;
		path = path.removeAll("&");
		path = path.removeAll("\"");
		path = path.removeAll("'");
		path = path.removeAll(",");
		path = path.removeAll("?");
		path = path.setSlash("/").replaceAll(" ", "-");	
		path = path.replaceAll("----", "-");
		path = path.replaceAll("---", "-");
		path = path.replaceAll("--", "-");
		return path.toLowerCase();
	},
	pascalToCamelCase: function(){
		var word = this;
		
		// no change if already begins with lowercase letter
		if (word.substr(0, 1).isLowercase()) {
			return word;
		}
		
		// make the first word lowercase
		
		// if >2 chars are uppercase
		var num = word.countStartingUppercase();
		if (num > 2) {	
			
			// lowercase all uppercase chars (except the last)
			return word.lowercaseFirstX(num - 1);
		}
		
		// lowercase first char only
		return word.lowercaseFirst();
	},
	uppercaseFirstX: function(numOfChars){
		var text = this;
		return text.setRange(0, numOfChars - 1, text.range(0, numOfChars - 1).toUpperCase());
	},
	lowercaseFirstX: function(numOfChars){
		var text = this;
		return text.setRange(0, numOfChars - 1, text.range(0, numOfChars - 1).toLowerCase());
	},
	none:null
};

// register funcs
UB.registerFuncs(String.prototype, stringFuncs);