   load: (loadOptions) ->
     @_parseLoadOptions(loadOptions)
 
-    options = @loadOptions
-
-    unless options.cache == false
+    unless @loadOptions.cache == false
       if @loadOptions.only?
         alreadyLoadedIds = _.select @loadOptions.only, (id) => @cachedCollection.get(id)?.associationsAreLoaded(@loadOptions.include)
         if alreadyLoadedIds.length == @loadOptions.only.length
           # We've already seen every id that is being asked for and have all the associated data.
-          @_success options, @collection, _.map @loadOptions.only, (id) => @cachedCollection.get(id)
+          @_success @loadOptions, @collection, _.map @loadOptions.only, (id) => @cachedCollection.get(id)
           return @collection
       else
         # Check if we have, at some point, requested enough records with this this order and filter(s).
         if @storageManager.getCollectionDetails(@loadOptions.name).cache[@loadOptions.cacheKey]
           subset = _(@storageManager.getCollectionDetails(@loadOptions.name).cache[@loadOptions.cacheKey]).map (result) => @storageManager.storage(result.key).get(result.id)
           if (_.all(subset, (model) => model.associationsAreLoaded(@loadOptions.include)))
-            @_success options, @collection, subset
+            @_success @loadOptions, @collection, subset
             return @collection
 
     # If we haven't returned yet, we need to go to the server to load some missing data.
     syncOptions =
       data: {}
       parse: true
-      error: options.error
+      error: @loadOptions.error
       success: (resp, status, xhr) =>
         # The server response should look something like this:
         #  {

    _.extend(syncOptions.data, _(@loadOptions.filters).omit('include', 'only', 'order', 'per_page', 'page', 'limit', 'offset', 'search')) if _(@loadOptions.filters).keys().length

    unless @loadOptions.only?
      if options.limit? && options.offset?
        syncOptions.data.limit = options.limit
        syncOptions.data.offset = options.offset
      else
        syncOptions.data.per_page = options.perPage
        syncOptions.data.page = options.page

    syncOptions.data.search = @loadOptions.search if @loadOptions.search

    modelOrCollection = @collection
    modelOrCollection = options.model if @loadOptions.only && options.model
    
    jqXhr = Backbone.sync.call @collection, 'read', modelOrCollection, syncOptions

    if options.returnValues
      options.returnValues.jqXhr = jqXhr

    @collection


        for underscoredModelName in keys
          @storageManager.storage(underscoredModelName).update _(resp[underscoredModelName]).values()

        unless @loadOptions.cache == false || @loadOptions.only?
          @storageManager.getCollectionDetails(@loadOptions.name).cache[@loadOptions.cacheKey] = results

        if @loadOptions.only?
          @_success @loadOptions, @collection, _.map(@loadOptions.only, (id) => @cachedCollection.get(id))
        else
          @_success @loadOptions, @collection, _(results).map (result) -> base.data.storage(result.key).get(result.id)

    syncOptions.data.include = @loadOptions.include.join(",") if @loadOptions.include.length
    syncOptions.data.only = _.difference(@loadOptions.only, alreadyLoadedIds).join(",") if @loadOptions.only?
