← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/static/javascript/yui/build/substitute/substitute.js

  • Committer: Matt Nordhoff
  • Date: 2010-02-26 04:37:13 UTC
  • mfrom: (400 trunk)
  • mto: This revision was merged to the branch mainline in revision 401.
  • Revision ID: mnordhoff@mattnordhoff.com-20100226043713-7mw3r6dr9qowutmi
Merge trunk for NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/static/javascript/yui/build/substitute/substitute.js
 
1
/*
 
2
Copyright (c) 2008, Yahoo! Inc. All rights reserved.
 
3
Code licensed under the BSD License:
 
4
http://developer.yahoo.net/yui/license.txt
 
5
version: 3.0.0pr2
 
6
*/
 
7
/**
 
8
 * String variable substitution and string formatting.
 
9
 * If included, the substitute method is added to the YUI instance.
 
10
 *
 
11
 * @module substitute
 
12
 */
 
13
YUI.add("substitute", function(Y) {
 
14
 
 
15
    var L = Y.Lang, DUMP='dump', SPACE=' ', LBRACE='{', RBRACE='}',
 
16
 
 
17
    /**
 
18
     * The following methods are added to the YUI instance
 
19
     * @class YUI~substitute
 
20
     */
 
21
 
 
22
    /**
 
23
     * Does variable substitution on a string. It scans through the string 
 
24
     * looking for expressions enclosed in { } braces. If an expression 
 
25
     * is found, it is used a key on the object.  If there is a space in
 
26
     * the key, the first word is used for the key and the rest is provided
 
27
     * to an optional function to be used to programatically determine the
 
28
     * value (the extra information might be used for this decision). If 
 
29
     * the value for the key in the object, or what is returned from the
 
30
     * function has a string value, number value, or object value, it is 
 
31
     * substituted for the bracket expression and it repeats.  If this
 
32
     * value is an object, it uses the Object's toString() if this has
 
33
     * been overridden, otherwise it does a shallow dump of the key/value
 
34
     * pairs if Y.dump is available (if dump isn't available, toString()
 
35
     * is used).
 
36
     *
 
37
     * This method is included in the 'substitute' module.  It is not included
 
38
     * in the YUI module.
 
39
     *
 
40
     * @method substitute
 
41
     * @for YUI
 
42
     * @param s {string} The string that will be modified.
 
43
     * @param o An object containing the replacement values
 
44
     * @param f {function} An optional function that can be used to
 
45
     *                     process each match.  It receives the key,
 
46
     *                     value, and any extra metadata included with
 
47
     *                     the key inside of the braces.
 
48
     * @return {string} the substituted string
 
49
     */
 
50
    substitute = function (s, o, f) {
 
51
        var i, j, k, key, v, meta, saved=[], token;
 
52
 
 
53
        for (;;) {
 
54
            i = s.lastIndexOf(LBRACE);
 
55
            if (i < 0) {
 
56
                break;
 
57
            }
 
58
            j = s.indexOf(RBRACE, i);
 
59
            if (i + 1 >= j) {
 
60
                break;
 
61
            }
 
62
 
 
63
            //Extract key and meta info 
 
64
            token = s.substring(i + 1, j);
 
65
            key = token;
 
66
            meta = null;
 
67
            k = key.indexOf(SPACE);
 
68
            if (k > -1) {
 
69
                meta = key.substring(k + 1);
 
70
                key = key.substring(0, k);
 
71
            }
 
72
 
 
73
            // lookup the value
 
74
            v = o[key];
 
75
 
 
76
            // if a substitution function was provided, execute it
 
77
            if (f) {
 
78
                v = f(key, v, meta);
 
79
            }
 
80
 
 
81
            if (L.isObject(v)) {
 
82
                if (!Y.dump) {
 
83
                    v = v.toString();
 
84
                } else {
 
85
                    if (L.isArray(v)) {
 
86
                        v = Y.dump(v, parseInt(meta, 10));
 
87
                    } else {
 
88
                        meta = meta || "";
 
89
 
 
90
                        // look for the keyword 'dump', if found force obj dump
 
91
                        var dump = meta.indexOf(DUMP);
 
92
                        if (dump > -1) {
 
93
                            meta = meta.substring(4);
 
94
                        }
 
95
 
 
96
                        // use the toString if it is not the Object toString 
 
97
                        // and the 'dump' meta info was not found
 
98
                        if (v.toString===Object.prototype.toString||dump>-1) {
 
99
                            v = Y.dump(v, parseInt(meta, 10));
 
100
                        } else {
 
101
                            v = v.toString();
 
102
                        }
 
103
                    }
 
104
                }
 
105
            } else if (!L.isString(v) && !L.isNumber(v)) {
 
106
                // This {block} has no replace string. Save it for later.
 
107
                v = "~-" + saved.length + "-~";
 
108
                saved[saved.length] = token;
 
109
 
 
110
                // break;
 
111
            }
 
112
 
 
113
            s = s.substring(0, i) + v + s.substring(j + 1);
 
114
 
 
115
 
 
116
        }
 
117
 
 
118
        // restore saved {block}s
 
119
        for (i=saved.length-1; i>=0; i=i-1) {
 
120
            s = s.replace(new RegExp("~-" + i + "-~"), "{"  + saved[i] + "}", "g");
 
121
        }
 
122
 
 
123
        return s;
 
124
 
 
125
    };
 
126
 
 
127
    Y.substitute = substitute;
 
128
    L.substitute = substitute;
 
129
 
 
130
}, "3.0.0pr2", {
 
131
    optional: ['dump']
 
132
});