Spaces:
Running
Running
File size: 3,529 Bytes
30c32c8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
const log = require('./log');
class StringUtil {
static withoutTrailingDigits (s) {
let i = s.length - 1;
while ((i >= 0) && ('0123456789'.indexOf(s.charAt(i)) > -1)) i--;
return s.slice(0, i + 1);
}
static unusedName (name, existingNames) {
if (existingNames.indexOf(name) < 0) return name;
name = StringUtil.withoutTrailingDigits(name);
let i = 2;
while (existingNames.indexOf(name + i) >= 0) i++;
return name + i;
}
/**
* Split a string on the first occurrence of a split character.
* @param {string} text - the string to split.
* @param {string} separator - split the text on this character.
* @returns {string[]} - the two parts of the split string, or [text, null] if no split character found.
* @example
* // returns ['foo', 'tar.gz']
* splitFirst('foo.tar.gz', '.');
* @example
* // returns ['foo', null]
* splitFirst('foo', '.');
* @example
* // returns ['foo', '']
* splitFirst('foo.', '.');
*/
static splitFirst (text, separator) {
const index = text.indexOf(separator);
if (index >= 0) {
return [text.substring(0, index), text.substring(index + 1)];
}
return [text, null];
}
/**
* A customized version of JSON.stringify that sets Infinity/NaN to 0,
* instead of the default (null).
* Needed because null is not of type number, but Infinity/NaN are, which
* can lead to serialization producing JSON that isn't valid based on the parser schema.
* It is also consistent with the behavior of saving 2.0 projects.
* This is only needed when stringifying an object for saving.
*
* @param {!object} obj - The object to serialize
* @return {!string} The JSON.stringified string with Infinity/NaN replaced with 0
*/
static stringify (obj) {
return JSON.stringify(obj, (_key, value) => {
if (typeof value === 'number' &&
(value === Infinity || value === -Infinity || isNaN(value))){
return 0;
}
return value;
});
}
/**
* A function to replace unsafe characters (not allowed in XML) with safe ones. This is used
* in cases where we're replacing non-user facing strings (e.g. variable IDs).
* When replacing user facing strings, the xmlEscape utility function should be used
* instead so that the user facing string does not change how it displays.
* @param {!string | !Array.<string>} unsafe Unsafe string possibly containing unicode control characters.
* In some cases this argument may be an array (e.g. hacked inputs from 2.0)
* @return {string} String with control characters replaced.
*/
static replaceUnsafeChars (unsafe) {
if (typeof unsafe !== 'string') {
if (Array.isArray(unsafe)) {
// This happens when we have hacked blocks from 2.0
// See #1030
unsafe = String(unsafe);
} else {
log.error('Unexpected input recieved in replaceUnsafeChars');
return unsafe;
}
}
return unsafe.replace(/[<>&'"]/g, c => {
switch (c) {
case '<': return 'lt';
case '>': return 'gt';
case '&': return 'amp';
case '\'': return 'apos';
case '"': return 'quot';
}
});
}
}
module.exports = StringUtil;
|