[Summary view] [Print] [Text view]

   1  /*
   2  YUI 3.17.2 (build 9c3c78e)
   3  Copyright 2014 Yahoo! Inc. All rights reserved.
   4  Licensed under the BSD License.
   5  http://yuilibrary.com/license/
   6  */
   7  
   8  YUI.add('autocomplete-sources', function (Y, NAME) {
   9  
  10  /**
  11  Mixes support for JSONP and YQL result sources into AutoCompleteBase.
  12  
  13  @module autocomplete
  14  @submodule autocomplete-sources
  15  **/
  16  
  17  var ACBase = Y.AutoCompleteBase,
  18      Lang   = Y.Lang,
  19  
  20      _SOURCE_SUCCESS = '_sourceSuccess',
  21  
  22      MAX_RESULTS         = 'maxResults',
  23      REQUEST_TEMPLATE    = 'requestTemplate',
  24      RESULT_LIST_LOCATOR = 'resultListLocator';
  25  
  26  // Add prototype properties and methods to AutoCompleteBase.
  27  Y.mix(ACBase.prototype, {
  28      /**
  29      Regular expression used to determine whether a String source is a YQL query.
  30  
  31      @property _YQL_SOURCE_REGEX
  32      @type RegExp
  33      @protected
  34      @for AutoCompleteBase
  35      **/
  36      _YQL_SOURCE_REGEX: /^(?:select|set|use)\s+/i,
  37  
  38      /**
  39      Runs before AutoCompleteBase's `_createObjectSource()` method and augments
  40      it to support additional object-based source types.
  41  
  42      @method _beforeCreateObjectSource
  43      @param {String} source
  44      @protected
  45      @for AutoCompleteBase
  46      **/
  47      _beforeCreateObjectSource: function (source) {
  48          // If the object is a <select> node, use the options as the result
  49          // source.
  50          if (source instanceof Y.Node &&
  51                  source.get('nodeName').toLowerCase() === 'select') {
  52  
  53              return this._createSelectSource(source);
  54          }
  55  
  56          // If the object is a JSONPRequest instance, try to use it as a JSONP
  57          // source.
  58          if (Y.JSONPRequest && source instanceof Y.JSONPRequest) {
  59              return this._createJSONPSource(source);
  60          }
  61  
  62          // Fall back to a basic object source.
  63          return this._createObjectSource(source);
  64      },
  65  
  66      /**
  67      Creates a DataSource-like object that uses `Y.io` as a source. See the
  68      `source` attribute for more details.
  69  
  70      @method _createIOSource
  71      @param {String} source URL.
  72      @return {Object} DataSource-like object.
  73      @protected
  74      @for AutoCompleteBase
  75      **/
  76      _createIOSource: function (source) {
  77          var ioSource = {type: 'io'},
  78              that     = this,
  79              ioRequest, lastRequest, loading;
  80  
  81          // Private internal _sendRequest method that will be assigned to
  82          // ioSource.sendRequest once io-base and json-parse are available.
  83          function _sendRequest(request) {
  84              var cacheKey = request.request;
  85  
  86              // Return immediately on a cached response.
  87              if (that._cache && cacheKey in that._cache) {
  88                  that[_SOURCE_SUCCESS](that._cache[cacheKey], request);
  89                  return;
  90              }
  91  
  92              // Cancel any outstanding requests.
  93              if (ioRequest && ioRequest.isInProgress()) {
  94                  ioRequest.abort();
  95              }
  96  
  97              ioRequest = Y.io(that._getXHRUrl(source, request), {
  98                  on: {
  99                      success: function (tid, response) {
 100                          var data;
 101  
 102                          try {
 103                              data = Y.JSON.parse(response.responseText);
 104                          } catch (ex) {
 105                              Y.error('JSON parse error', ex);
 106                          }
 107  
 108                          if (data) {
 109                              that._cache && (that._cache[cacheKey] = data);
 110                              that[_SOURCE_SUCCESS](data, request);
 111                          }
 112                      }
 113                  }
 114              });
 115          }
 116  
 117          ioSource.sendRequest = function (request) {
 118              // Keep track of the most recent request in case there are multiple
 119              // requests while we're waiting for the IO module to load. Only the
 120              // most recent request will be sent.
 121              lastRequest = request;
 122  
 123              if (loading) { return; }
 124  
 125              loading = true;
 126  
 127              // Lazy-load the io-base and json-parse modules if necessary,
 128              // then overwrite the sendRequest method to bypass this check in
 129              // the future.
 130              Y.use('io-base', 'json-parse', function () {
 131                  ioSource.sendRequest = _sendRequest;
 132                  _sendRequest(lastRequest);
 133              });
 134          };
 135  
 136          return ioSource;
 137      },
 138  
 139      /**
 140      Creates a DataSource-like object that uses the specified JSONPRequest
 141      instance as a source. See the `source` attribute for more details.
 142  
 143      @method _createJSONPSource
 144      @param {JSONPRequest|String} source URL string or JSONPRequest instance.
 145      @return {Object} DataSource-like object.
 146      @protected
 147      @for AutoCompleteBase
 148      **/
 149      _createJSONPSource: function (source) {
 150          var jsonpSource = {type: 'jsonp'},
 151              that        = this,
 152              lastRequest, loading;
 153  
 154          function _sendRequest(request) {
 155              var cacheKey = request.request,
 156                  query    = request.query;
 157  
 158              if (that._cache && cacheKey in that._cache) {
 159                  that[_SOURCE_SUCCESS](that._cache[cacheKey], request);
 160                  return;
 161              }
 162  
 163              // Hack alert: JSONPRequest currently doesn't support
 164              // per-request callbacks, so we're reaching into the protected
 165              // _config object to make it happen.
 166              //
 167              // This limitation is mentioned in the following JSONP
 168              // enhancement ticket:
 169              //
 170              // http://yuilibrary.com/projects/yui3/ticket/2529371
 171              source._config.on.success = function (data) {
 172                  that._cache && (that._cache[cacheKey] = data);
 173                  that[_SOURCE_SUCCESS](data, request);
 174              };
 175  
 176              source.send(query);
 177          }
 178  
 179          jsonpSource.sendRequest = function (request) {
 180              // Keep track of the most recent request in case there are multiple
 181              // requests while we're waiting for the JSONP module to load. Only
 182              // the most recent request will be sent.
 183              lastRequest = request;
 184  
 185              if (loading) { return; }
 186  
 187              loading = true;
 188  
 189              // Lazy-load the JSONP module if necessary, then overwrite the
 190              // sendRequest method to bypass this check in the future.
 191              Y.use('jsonp', function () {
 192                  // Turn the source into a JSONPRequest instance if it isn't
 193                  // one already.
 194                  if (!(source instanceof Y.JSONPRequest)) {
 195                      source = new Y.JSONPRequest(source, {
 196                          format: Y.bind(that._jsonpFormatter, that)
 197                      });
 198                  }
 199  
 200                  jsonpSource.sendRequest = _sendRequest;
 201                  _sendRequest(lastRequest);
 202              });
 203          };
 204  
 205          return jsonpSource;
 206      },
 207  
 208      /**
 209      Creates a DataSource-like object that uses the specified `<select>` node as
 210      a source.
 211  
 212      @method _createSelectSource
 213      @param {Node} source YUI Node instance wrapping a `<select>` node.
 214      @return {Object} DataSource-like object.
 215      @protected
 216      @for AutoCompleteBase
 217      **/
 218      _createSelectSource: function (source) {
 219          var that = this;
 220  
 221          return {
 222              type: 'select',
 223              sendRequest: function (request) {
 224                  var options = [];
 225  
 226                  source.get('options').each(function (option) {
 227                      options.push({
 228                          html    : option.get('innerHTML'),
 229                          index   : option.get('index'),
 230                          node    : option,
 231                          selected: option.get('selected'),
 232                          text    : option.get('text'),
 233                          value   : option.get('value')
 234                      });
 235                  });
 236  
 237                  that[_SOURCE_SUCCESS](options, request);
 238              }
 239          };
 240      },
 241  
 242      /**
 243      Creates a DataSource-like object that calls the specified  URL or executes
 244      the specified YQL query for results. If the string starts with "select ",
 245      "use ", or "set " (case-insensitive), it's assumed to be a YQL query;
 246      otherwise, it's assumed to be a URL (which may be absolute or relative).
 247      URLs containing a "{callback}" placeholder are assumed to be JSONP URLs; all
 248      others will use XHR. See the `source` attribute for more details.
 249  
 250      @method _createStringSource
 251      @param {String} source URL or YQL query.
 252      @return {Object} DataSource-like object.
 253      @protected
 254      @for AutoCompleteBase
 255      **/
 256      _createStringSource: function (source) {
 257          if (this._YQL_SOURCE_REGEX.test(source)) {
 258              // Looks like a YQL query.
 259              return this._createYQLSource(source);
 260          } else if (source.indexOf('{callback}') !== -1) {
 261              // Contains a {callback} param and isn't a YQL query, so it must be
 262              // JSONP.
 263              return this._createJSONPSource(source);
 264          } else {
 265              // Not a YQL query or JSONP, so we'll assume it's an XHR URL.
 266              return this._createIOSource(source);
 267          }
 268      },
 269  
 270      /**
 271      Creates a DataSource-like object that uses the specified YQL query string to
 272      create a YQL-based source. See the `source` attribute for details. If no
 273      `resultListLocator` is defined, this method will set a best-guess locator
 274      that might work for many typical YQL queries.
 275  
 276      @method _createYQLSource
 277      @param {String} source YQL query.
 278      @return {Object} DataSource-like object.
 279      @protected
 280      @for AutoCompleteBase
 281      **/
 282      _createYQLSource: function (source) {
 283          var that      = this,
 284              yqlSource = {type: 'yql'},
 285              lastRequest, loading, yqlRequest;
 286  
 287          if (!that.get(RESULT_LIST_LOCATOR)) {
 288              that.set(RESULT_LIST_LOCATOR, that._defaultYQLLocator);
 289          }
 290  
 291          function _sendRequest(request) {
 292              var query      = request.query,
 293                  env        = that.get('yqlEnv'),
 294                  maxResults = that.get(MAX_RESULTS),
 295                  callback, opts, yqlQuery;
 296  
 297              yqlQuery = Lang.sub(source, {
 298                  maxResults: maxResults > 0 ? maxResults : 1000,
 299                  request   : request.request,
 300                  query     : query
 301              });
 302  
 303              if (that._cache && yqlQuery in that._cache) {
 304                  that[_SOURCE_SUCCESS](that._cache[yqlQuery], request);
 305                  return;
 306              }
 307  
 308              callback = function (data) {
 309                  that._cache && (that._cache[yqlQuery] = data);
 310                  that[_SOURCE_SUCCESS](data, request);
 311              };
 312  
 313              opts = {proto: that.get('yqlProtocol')};
 314  
 315              // Only create a new YQLRequest instance if this is the
 316              // first request. For subsequent requests, we'll reuse the
 317              // original instance.
 318              if (yqlRequest) {
 319                  yqlRequest._callback   = callback;
 320                  yqlRequest._opts       = opts;
 321                  yqlRequest._params.q   = yqlQuery;
 322  
 323                  if (env) {
 324                      yqlRequest._params.env = env;
 325                  }
 326              } else {
 327                  yqlRequest = new Y.YQLRequest(yqlQuery, {
 328                      on: {success: callback},
 329                      allowCache: false // temp workaround until JSONP has per-URL callback proxies
 330                  }, env ? {env: env} : null, opts);
 331              }
 332  
 333              yqlRequest.send();
 334          }
 335  
 336          yqlSource.sendRequest = function (request) {
 337              // Keep track of the most recent request in case there are multiple
 338              // requests while we're waiting for the YQL module to load. Only the
 339              // most recent request will be sent.
 340              lastRequest = request;
 341  
 342              if (!loading) {
 343                  // Lazy-load the YQL module if necessary, then overwrite the
 344                  // sendRequest method to bypass this check in the future.
 345                  loading = true;
 346  
 347                  Y.use('yql', function () {
 348                      yqlSource.sendRequest = _sendRequest;
 349                      _sendRequest(lastRequest);
 350                  });
 351              }
 352          };
 353  
 354          return yqlSource;
 355      },
 356  
 357      /**
 358      Default resultListLocator used when a string-based YQL source is set and the
 359      implementer hasn't already specified one.
 360  
 361      @method _defaultYQLLocator
 362      @param {Object} response YQL response object.
 363      @return {Array}
 364      @protected
 365      @for AutoCompleteBase
 366      **/
 367      _defaultYQLLocator: function (response) {
 368          var results = response && response.query && response.query.results,
 369              values;
 370  
 371          if (results && Lang.isObject(results)) {
 372              // If there's only a single value on YQL's results object, that
 373              // value almost certainly contains the array of results we want. If
 374              // there are 0 or 2+ values, then the values themselves are most
 375              // likely the results we want.
 376              values  = Y.Object.values(results) || [];
 377              results = values.length === 1 ? values[0] : values;
 378  
 379              if (!Lang.isArray(results)) {
 380                  results = [results];
 381              }
 382          } else {
 383              results = [];
 384          }
 385  
 386          return results;
 387      },
 388  
 389      /**
 390      Returns a formatted XHR URL based on the specified base _url_, _query_, and
 391      the current _requestTemplate_ if any.
 392  
 393      @method _getXHRUrl
 394      @param {String} url Base URL.
 395      @param {Object} request Request object containing `query` and `request`
 396        properties.
 397      @return {String} Formatted URL.
 398      @protected
 399      @for AutoCompleteBase
 400      **/
 401      _getXHRUrl: function (url, request) {
 402          var maxResults = this.get(MAX_RESULTS);
 403  
 404          if (request.query !== request.request) {
 405              // Append the request template to the URL.
 406              url += request.request;
 407          }
 408  
 409          return Lang.sub(url, {
 410              maxResults: maxResults > 0 ? maxResults : 1000,
 411              query     : encodeURIComponent(request.query)
 412          });
 413      },
 414  
 415      /**
 416      URL formatter passed to `JSONPRequest` instances.
 417  
 418      @method _jsonpFormatter
 419      @param {String} url
 420      @param {String} proxy
 421      @param {String} query
 422      @return {String} Formatted URL
 423      @protected
 424      @for AutoCompleteBase
 425      **/
 426      _jsonpFormatter: function (url, proxy, query) {
 427          var maxResults      = this.get(MAX_RESULTS),
 428              requestTemplate = this.get(REQUEST_TEMPLATE);
 429  
 430          if (requestTemplate) {
 431              url += requestTemplate(query);
 432          }
 433  
 434          return Lang.sub(url, {
 435              callback  : proxy,
 436              maxResults: maxResults > 0 ? maxResults : 1000,
 437              query     : encodeURIComponent(query)
 438          });
 439      }
 440  });
 441  
 442  // Add attributes to AutoCompleteBase.
 443  Y.mix(ACBase.ATTRS, {
 444      /**
 445      YQL environment file URL to load when the `source` is set to a YQL query.
 446      Set this to `null` to use the default Open Data Tables environment file
 447      (http://datatables.org/alltables.env).
 448  
 449      @attribute yqlEnv
 450      @type String
 451      @default null
 452      @for AutoCompleteBase
 453      **/
 454      yqlEnv: {
 455          value: null
 456      },
 457  
 458      /**
 459      URL protocol to use when the `source` is set to a YQL query.
 460  
 461      @attribute yqlProtocol
 462      @type String
 463      @default 'http'
 464      @for AutoCompleteBase
 465      **/
 466      yqlProtocol: {
 467          value: 'http'
 468      }
 469  });
 470  
 471  // Tell AutoCompleteBase about the new source types it can now support.
 472  Y.mix(ACBase.SOURCE_TYPES, {
 473      io    : '_createIOSource',
 474      jsonp : '_createJSONPSource',
 475      object: '_beforeCreateObjectSource', // Run our version before the base version.
 476      select: '_createSelectSource',
 477      string: '_createStringSource',
 478      yql   : '_createYQLSource'
 479  }, true);
 480  
 481  
 482  }, '3.17.2', {"optional": ["io-base", "json-parse", "jsonp", "yql"], "requires": ["autocomplete-base"]});