• Classes
• Modules
• Everything

 var JSONPRequest = Y.JSONPRequest,
 getByPath = Y.Object.getValue,
 noop = function () {};
 
 /**
 * Adds support for parsing complex callback identifiers from the jsonp url.
 * This includes callback=foo[1]bar.baz["goo"] as well as referencing methods
 * in the YUI instance.
 *
 * @module jsonp
 * @submodule jsonp-url
 * @for JSONPRequest
 */
 
 Y.mix(JSONPRequest.prototype, {
 /**
 * RegExp used by the default URL formatter to insert the generated callback
 * name into the JSONP url. Looks for a query param callback=. If a value
 * is assigned, it will be clobbered.
 *
 * @property _pattern
 * @type RegExp
 * @default /\bcallback=.*?(?=&|$)/i
 * @protected
 */
 _pattern: /\bcallback=(.*?)(?=&|$)/i,
 
 /**
 * Template used by the default URL formatter to add the callback function
 * name to the url.
 *
 * @property _template
 * @type String
 * @default "callback={callback}"
 * @protected
 */
 _template: "callback={callback}",
 
 /**
 * <p>Parses the url for a callback named explicitly in the string.
 * Override this if the target JSONP service uses a different query
 * parameter or url format.</p>
 *
 * <p>If the callback is declared inline, the corresponding function will
 * be returned. Otherwise null.</p>
 *
 * @method _defaultCallback
 * @param url {String} the url to search in
 * @return {Function} the callback function if found, or null
 * @protected
 */
 _defaultCallback: function (url) {
 var match = url.match(this._pattern),
 keys = [],
 i = 0,
 locator, path, callback;
 
 if (match) {
 // Strip the ["string keys"] and [1] array indexes
 locator = match[1]
 .replace(/\[(['"])(.*?)1円\]/g,
 function (x, 1,ドル 2ドル) {
 keys[i] = 2ドル;
 return '.@' + (i++);
 })
 .replace(/\[(\d+)\]/g,
 function (x, 1ドル) {
 /*jslint bitwise: true */
 keys[i] = parseInt(1,ドル 10) | 0;
 return '.@' + (i++);
 })
 .replace(/^\./, ''); // remove leading dot
 
 // Validate against problematic characters.
 if (!/[^\w\.\$@]/.test(locator)) {
 path = locator.split('.');
 for (i = path.length - 1; i >= 0; --i) {
 if (path[i].charAt(0) === '@') {
 path[i] = keys[parseInt(path[i].substr(1), 10)];
 }
 }
 
 // First look for a global function, then the Y, then try the Y
 // again from the second token (to support "callback=Y.handler")
 callback = getByPath(Y.config.win, path) ||
 getByPath(Y, path) ||
 getByPath(Y, path.slice(1));
 }
 }
 
 return callback || noop;
 },
 
 /**
 * URL formatter that looks for callback= in the url and appends it
 * if not present. The supplied proxy name will be assigned to the query
 * param. Override this method by passing a function as the
 * &quot;format&quot; property in the config object to the constructor.
 *
 * @method _format
 * @param url { String } the original url
 * @param proxy {String} the function name that will be used as a proxy to
 * the configured callback methods.
 * @return {String} fully qualified JSONP url
 * @protected
 */
 _format: function (url, proxy) {
 var callbackRE = /\{callback\}/,
 callback, lastChar;
 
 if (callbackRE.test(url)) {
 return url.replace(callbackRE, proxy);
 }
 
 callback = this._template.replace(callbackRE, proxy);
 
 if (this._pattern.test(url)) {
 return url.replace(this._pattern, callback);
 } else {
 lastChar = url.slice(-1);
 if (lastChar !== '&' && lastChar !== '?') {
 url += (url.indexOf('?') > -1) ? '&' : '?';
 }
 return url + callback;
 }
 }
 
 }, true);