/**
* String variable substitution and string formatting.
* If included, the substitute method is added to the YUI instance.
*
* @module substitute
* @deprecated
*/
var L = Y.Lang, DUMP = 'dump', SPACE = ' ', LBRACE = '{', RBRACE = '}',
savedRegExp = /(~-(\d+)-~)/g, lBraceRegExp = /\{LBRACE\}/g, rBraceRegExp = /\{RBRACE\}/g,
/**
* The following methods are added to the YUI instance
*
* <strong>Use `Y.Lang.sub` or `Y.Template` instead.</strong>
* @class YUI~substitute
* @deprecated
*/
/**
<strong>Use `Y.Lang.sub` or `Y.Template` instead.</strong>
Does `{placeholder}` substitution on a string. The object passed as the
second parameter provides values to replace the `{placeholder}`s.
{placeholder} token names must match property names of the object. For
example
`var greeting = Y.substitute("Hello, {who}!", { who: "World" });`
`{placeholder}` tokens that are undefined on the object map will be left in
tact (leaving unsightly "{placeholder}"s in the output string). If your
replacement strings *should* include curly braces, use `{LBRACE}` and
`{RBRACE}` in your object map string value.
If a function is passed as a third argument, it will be called for each
{placeholder} found. The {placeholder} name is passed as the first value
and the value from the object map is passed as the second. If the
{placeholder} contains a space, the first token will be used to identify
the object map property and the remainder will be passed as a third
argument to the function. See below for an example.
If the value in the object map for a given {placeholder} is an object and
the `dump` module is loaded, the replacement value will be the string
result of calling `Y.dump(...)` with the object as input. Include a
numeric second token in the {placeholder} to configure the depth of the call
to `Y.dump(...)`, e.g. "{someObject 2}". See the
<a href="../classes/YUI.html#method_dump">`dump`</a> method for details.
@method substitute
@deprecated
@param {string} s The string that will be modified.
@param {object} o An object containing the replacement values.
@param {function} f An optional function that can be used to
process each match. It receives the key,
value, and any extra metadata included with
the key inside of the braces.
@param {boolean} recurse if true, the replacement will be recursive,
letting you have replacement tokens in replacement text.
The default is false.
@return {string} the substituted string.
@example
function getAttrVal(key, value, name) {
// Return a string describing the named attribute and its value if
// the first token is @. Otherwise, return the value from the
// replacement object.
if (key === "@") {
value += name + " Value: " + myObject.get(name);
}
return value;
}
// Assuming myObject.set('foo', 'flowers'),
// => "Attr: foo Value: flowers"
var attrVal = Y.substitute("{@ foo}", { "@": "Attr: " }, getAttrVal);
**/
substitute = function(s, o, f, recurse) {
var i, j, k, key, v, meta, saved = [], token, dump,
lidx = s.length;
for (;;) {
i = s.lastIndexOf(LBRACE, lidx);
if (i < 0) {
break;
}
j = s.indexOf(RBRACE, i);
if (i + 1 >= j) {
break;
}
//Extract key and meta info
token = s.substring(i + 1, j);
key = token;
meta = null;
k = key.indexOf(SPACE);
if (k > -1) {
meta = key.substring(k + 1);
key = key.substring(0, k);
}
// lookup the value
v = o[key];
// if a substitution function was provided, execute it
if (f) {
v = f(key, v, meta);
}
if (L.isObject(v)) {
if (!Y.dump) {
v = v.toString();
} else {
if (L.isArray(v)) {
v = Y.dump(v, parseInt(meta, 10));
} else {
meta = meta || '';
// look for the keyword 'dump', if found force obj dump
dump = meta.indexOf(DUMP);
if (dump > -1) {
meta = meta.substring(4);
}
// use the toString if it is not the Object toString
// and the 'dump' meta info was not found
if (v.toString === Object.prototype.toString ||
dump > -1) {
v = Y.dump(v, parseInt(meta, 10));
} else {
v = v.toString();
}
}
}
} else if (L.isUndefined(v)) {
// This {block} has no replace string. Save it for later.
v = '~-' + saved.length + '-~';
saved.push(token);
// break;
}
s = s.substring(0, i) + v + s.substring(j + 1);
if (!recurse) {
lidx = i - 1;
}
}
// restore saved {block}s and escaped braces
return s
.replace(savedRegExp, function (str, p1, p2) {
return LBRACE + saved[parseInt(p2,10)] + RBRACE;
})
.replace(lBraceRegExp, LBRACE)
.replace(rBraceRegExp, RBRACE)
;
};
Y.substitute = substitute;
L.substitute = substitute;