← Back to branch summary

~ubuntuone-pqm-team/yui/stable-min

« back to all changes in this revision

Viewing changes to build/jsonp-url/jsonp-url-debug.js

  • Committer: Ricardo Kirkner
  • Date: 2014-09-23 20:17:06 UTC
  • Revision ID: ricardo.kirkner@canonical.com-20140923201706-17kwxwckw6orp28k
re-added all .js files

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/jsonp-url/jsonp-url-debug.js
 
1
YUI.add('jsonp-url', function (Y, NAME) {
 
2
 
 
3
var JSONPRequest = Y.JSONPRequest,
 
4
    getByPath    = Y.Object.getValue,
 
5
    noop         = function () {};
 
6
 
 
7
/**
 
8
 * Adds support for parsing complex callback identifiers from the jsonp url.
 
9
 * This includes callback=foo[1]bar.baz["goo"] as well as referencing methods
 
10
 * in the YUI instance.
 
11
 *
 
12
 * @module jsonp
 
13
 * @submodule jsonp-url
 
14
 * @for JSONPRequest
 
15
 */
 
16
 
 
17
Y.mix(JSONPRequest.prototype, {
 
18
    /**
 
19
     * RegExp used by the default URL formatter to insert the generated callback
 
20
     * name into the JSONP url.  Looks for a query param callback=.  If a value
 
21
     * is assigned, it will be clobbered.
 
22
     *
 
23
     * @property _pattern
 
24
     * @type RegExp
 
25
     * @default /\bcallback=.*?(?=&|$)/i
 
26
     * @protected
 
27
     */
 
28
    _pattern: /\bcallback=(.*?)(?=&|$)/i,
 
29
 
 
30
    /**
 
31
     * Template used by the default URL formatter to add the callback function
 
32
     * name to the url.
 
33
     *
 
34
     * @property _template
 
35
     * @type String
 
36
     * @default "callback={callback}"
 
37
     * @protected
 
38
     */
 
39
    _template: "callback={callback}",
 
40
 
 
41
    /**
 
42
     * <p>Parses the url for a callback named explicitly in the string.
 
43
     * Override this if the target JSONP service uses a different query
 
44
     * parameter or url format.</p>
 
45
     *
 
46
     * <p>If the callback is declared inline, the corresponding function will
 
47
     * be returned.  Otherwise null.</p>
 
48
     *
 
49
     * @method _defaultCallback
 
50
     * @param url {String} the url to search in
 
51
     * @return {Function} the callback function if found, or null
 
52
     * @protected
 
53
     */
 
54
    _defaultCallback: function (url) {
 
55
        var match = url.match(this._pattern),
 
56
            keys  = [],
 
57
            i = 0,
 
58
            locator, path, callback;
 
59
 
 
60
        if (match) {
 
61
            // Strip the ["string keys"] and [1] array indexes
 
62
            locator = match[1]
 
63
                .replace(/\[(['"])(.*?)\1\]/g,
 
64
                    function (x, $1, $2) {
 
65
                        keys[i] = $2;
 
66
                        return '.@' + (i++);
 
67
                    })
 
68
                .replace(/\[(\d+)\]/g,
 
69
                    function (x, $1) {
 
70
                        keys[i] = parseInt($1, 10) | 0;
 
71
                        return '.@' + (i++);
 
72
                    })
 
73
                .replace(/^\./, ''); // remove leading dot
 
74
 
 
75
            // Validate against problematic characters.
 
76
            if (!/[^\w\.\$@]/.test(locator)) {
 
77
                path = locator.split('.');
 
78
                for (i = path.length - 1; i >= 0; --i) {
 
79
                    if (path[i].charAt(0) === '@') {
 
80
                        path[i] = keys[parseInt(path[i].substr(1), 10)];
 
81
                    }
 
82
                }
 
83
 
 
84
                // First look for a global function, then the Y, then try the Y
 
85
                // again from the second token (to support "callback=Y.handler")
 
86
                callback = getByPath(Y.config.win, path) ||
 
87
                           getByPath(Y, path) ||
 
88
                           getByPath(Y, path.slice(1));
 
89
            }
 
90
        }
 
91
 
 
92
        return callback || noop;
 
93
    },
 
94
 
 
95
    /**
 
96
     * URL formatter that looks for callback= in the url and appends it
 
97
     * if not present.  The supplied proxy name will be assigned to the query
 
98
     * param.  Override this method by passing a function as the
 
99
     * &quot;format&quot; property in the config object to the constructor.
 
100
     *
 
101
     * @method _format
 
102
     * @param url { String } the original url
 
103
     * @param proxy {String} the function name that will be used as a proxy to
 
104
     *      the configured callback methods.
 
105
     * @return {String} fully qualified JSONP url
 
106
     * @protected
 
107
     */
 
108
    _format: function (url, proxy) {
 
109
        var callbackRE = /\{callback\}/,
 
110
            callback, lastChar;
 
111
 
 
112
        if (callbackRE.test(url)) {
 
113
            return url.replace(callbackRE, proxy);
 
114
        }
 
115
 
 
116
        callback = this._template.replace(callbackRE, proxy);
 
117
 
 
118
        if (this._pattern.test(url)) {
 
119
            return url.replace(this._pattern, callback);
 
120
        } else {
 
121
            lastChar = url.slice(-1);
 
122
            if (lastChar !== '&' && lastChar !== '?') {
 
123
                url += (url.indexOf('?') > -1) ? '&' : '?';
 
124
            }
 
125
            return url + callback;
 
126
        }
 
127
    }
 
128
 
 
129
}, true);
 
130
 
 
131
 
 
132
}, '@VERSION@', {"requires": ["jsonp"]});