/loggerhead/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/loggerhead/trunk

« back to all changes in this revision

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

  • Committer: Jelmer Vernooij
  • Date: 2020-06-04 19:43:36 UTC
  • mto: This revision was merged to the branch mainline in revision 500.
  • Revision ID: jelmer@jelmer.uk-20200604194336-ahskrf4rmy1qaxzs
Port loggerhead from YUI to jQuery.

YUI has been deprecated since 2014 and is due to be removed from Debian.

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
 
});