angularjs-rails-resource 2.2.2 → 2.3.0

data/vendor/assets/javascripts/angularjs/rails/resource/extensions/snapshots.js

@@ -9,8 +9,8 @@
 
         RailsResourceSnapshotsMixin.extended = function (Resource) {
             Resource.intercept('afterResponse', function (result, resource, context) {
-                if (context && context.hasOwnProperty('$snapshots') && angular.isArray(context.$snapshots)) {
-                    context.$snapshots.length = 0;
+                if (context && context.hasOwnProperty('$$snapshots') && angular.isArray(context.$$snapshots)) {
+                    context.$$snapshots.length = 0;
                 }
             });
 
@@ -27,7 +27,7 @@
 
         /**
          * Prepares a copy of the resource to be stored as a snapshot
-         * @returns {Resource} the copied resource, sans $snapshots
+         * @returns {Resource} the copied resource, sans $$snapshots
          */
         function _prepSnapshot() {
             var config = this.constructor.config,
@@ -35,13 +35,13 @@
 
             // we don't want to store our snapshots in the snapshots because that would make the rollback kind of funny
             // not to mention using more memory for each snapshot.
-            delete copy.$snapshots;
+            delete copy.$$snapshots;
 
             return copy
         }
 
         /**
-         * Stores a copy of this resource in the $snapshots array to allow undoing changes.
+         * Stores a copy of this resource in the $$snapshots array to allow undoing changes.
          * @param {function} rollbackCallback Optional callback function to be executed after the rollback.
          * @returns {Number} The version of the snapshot created (0-based index)
          */
@@ -50,12 +50,12 @@
 
             copy.$rollbackCallback = rollbackCallback;
 
-            if (!this.$snapshots) {
-                this.$snapshots = [];
+            if (!this.$$snapshots) {
+                this.$$snapshots = [];
             }
 
-            this.$snapshots.push(copy);
-            return this.$snapshots.length - 1;
+            this.$$snapshots.push(copy);
+            return this.$$snapshots.length - 1;
         }
 
         /**
@@ -76,8 +76,8 @@
         function rollbackTo(version) {
             var versions, rollbackCallback,
                 config = this.constructor.config,
-                snapshots = this.$snapshots,
-                snapshotsLength = this.$snapshots ? this.$snapshots.length : 0;
+                snapshots = this.$$snapshots,
+                snapshotsLength = this.$$snapshots ? this.$$snapshots.length : 0;
 
             // if an invalid snapshot version was specified then don't attempt to do anything
             if (!angular.isArray(snapshots) || snapshotsLength === 0 || !angular.isNumber(version)) {
@@ -94,7 +94,7 @@
             angular.extend(this, (config.snapshotSerializer || config.serializer).deserialize(versions[0]));
 
             // restore special variables
-            this.$snapshots = snapshots;
+            this.$$snapshots = snapshots;
             delete this.$rollbackCallback;
 
             if (angular.isFunction(rollbackCallback)) {
@@ -115,7 +115,7 @@
          * @returns {Boolean} true if rollback was successful, false otherwise
          */
         function rollback(numVersions) {
-            var snapshotsLength = this.$snapshots ? this.$snapshots.length : 0;
+            var snapshotsLength = this.$$snapshots ? this.$$snapshots.length : 0;
             numVersions = Math.min(numVersions || 1, snapshotsLength);
 
             if (numVersions < 0) {
@@ -123,7 +123,7 @@
             }
 
             if (snapshotsLength) {
-                this.rollbackTo(this.$snapshots.length - numVersions);
+                this.rollbackTo(this.$$snapshots.length - numVersions);
             }
 
             return true;
@@ -134,12 +134,12 @@
          * @returns {Boolean} true if the latest snapshot differs from resource as-is
          */
         function unsnappedChanges() {
-            if (!this.$snapshots) {
+            if (!this.$$snapshots) {
                 return true
             }
 
             var copy = this._prepSnapshot(),
-                latestSnap = this.$snapshots[this.$snapshots.length - 1]
+                latestSnap = this.$$snapshots[this.$$snapshots.length - 1]
 
             return !angular.equals(copy, latestSnap)
         }

data/vendor/assets/javascripts/angularjs/rails/resource/resource.js

@@ -108,8 +108,8 @@
             return this;
         };
 
-        this.$get = ['$http', '$q', 'railsUrlBuilder', 'railsSerializer', 'railsRootWrapper', 'RailsResourceInjector',
-            function ($http, $q, railsUrlBuilder, railsSerializer, railsRootWrapper, RailsResourceInjector) {
+        this.$get = ['$http', '$q', '$timeout', 'railsUrlBuilder', 'railsSerializer', 'railsRootWrapper', 'RailsResourceInjector',
+            function ($http, $q, $timeout, railsUrlBuilder, railsSerializer, railsRootWrapper, RailsResourceInjector) {
 
                 function RailsResource(value) {
                     if (value) {
@@ -118,6 +118,7 @@
                             response = railsRootWrapper.unwrap(response, this.constructor, true);
                         }
                         angular.extend(this, response.data);
+                        this.constructor.runInterceptorPhase('afterDeserialize', this);
                     }
                 }
 
@@ -219,6 +220,7 @@
                     this.config.underscoreParams = booleanParam(cfg.underscoreParams, defaultOptions.underscoreParams);
                     this.config.updateMethod = (cfg.updateMethod || defaultOptions.updateMethod).toLowerCase();
                     this.config.fullResponse = booleanParam(cfg.fullResponse, defaultOptions.fullResponse);
+                    this.config.singular = cfg.singular || defaultOptions.singular;
 
                     this.config.requestTransformers = cfg.requestTransformers ? cfg.requestTransformers.slice(0) : [];
                     this.config.responseInterceptors = cfg.responseInterceptors ? cfg.responseInterceptors.slice(0) : [];
@@ -313,6 +315,12 @@
                  * * afterResponseError: Interceptors get called when a previous interceptor threw an error or
                  *      resolved with a rejection.
                  *
+                 * Finally, for each deserialized resource including associations, deserialization phases are called.
+                 *
+                 * The valid deserialization phases are:
+                 *
+                 * * afterDeserialize: Interceptors are called after a resource has been deserialized.
+                 *
                  * @param {String | Object} interceptor
                  */
                 RailsResource.addInterceptor = function (interceptor) {
@@ -322,7 +330,7 @@
                 /**
                  * Adds an interceptor callback function for the specified phase.
                  * @param {String} phase The interceptor phase, one of:
-                 *      beforeRequest, request, beforeResponse, response, afterResponse
+                 *      beforeRequest, request, beforeResponse, response, afterResponse, afterDeserialize
                  * @param fn The function to call.
                  */
                 RailsResource.intercept = function (phase, fn) {
@@ -406,6 +414,16 @@
                     this.intercept('afterResponse', fn);
                 };
 
+                /**
+                 * Adds interceptor on 'afterDeserialize' phase.
+                 * @param fn(response data, constructor, context) - response data is either the resource instance returned or an array of resource instances,
+                 *      constructor is the resource class calling the function,
+                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
+                 */
+                RailsResource.interceptAfterDeserialize = function (fn) {
+                    this.intercept('afterDeserialize', fn);
+                };
+
                 /**
                  * Deprecated, see interceptors
                  * Add a callback to run on response.
@@ -505,6 +523,7 @@
                 };
 
                 RailsResource.runInterceptorPhase = function (phase, context, promise) {
+                    promise = promise || $q.resolve(context);
                     var config = this.config, chain = [];
 
                     forEachDependency(config.interceptors, function (interceptor) {
@@ -542,9 +561,25 @@
                  *      has completed.
                  */
                 RailsResource.$http = function (httpConfig, context, resourceConfigOverrides) {
-                    var config = angular.extend(angular.copy(this.config), resourceConfigOverrides || {}),
+                    var timeoutPromise, promise,
+                        config = angular.extend(angular.copy(this.config), resourceConfigOverrides || {}),
                         resourceConstructor = config.resourceConstructor,
-                        promise = $q.when(httpConfig);
+                        abortDeferred = $q.defer();
+
+                    function abortRequest() {
+                        abortDeferred.resolve();
+                    }
+
+                    if (httpConfig && httpConfig.timeout) {
+                        if (httpConfig.timeout > 0) {
+                            timeoutPromise = $timeout(abortDeferred.resolve, httpConfig.timeout);
+                        } else if (angular.isFunction(httpConfig.timeout.then)) {
+                            httpConfig.timeout.then(abortDeferred.resolve);
+                        }
+                    }
+
+                    httpConfig = angular.extend({}, httpConfig, {timeout: abortDeferred.promise});
+                    promise = $q.when(httpConfig);
 
                     if (!config.skipRequestProcessing) {
 
@@ -572,9 +607,19 @@
                         });
 
                     } else {
-
                         promise = $http(httpConfig);
+                    }
 
+                    // After the request has completed we need to cancel any pending timeout
+                    if (timeoutPromise) {
+                        // not using finally here to stay compatible with angular 1.0
+                        promise = promise.then(function (result) {
+                            $timeout.cancel(timeoutPromise);
+                            return result;
+                        }, function (error) {
+                            $timeout.cancel(timeoutPromise);
+                            return $q.reject(error);
+                        });
                     }
 
                     promise = this.runInterceptorPhase('beforeResponse', context, promise).then(function (response) {
@@ -607,9 +652,12 @@
 
                     promise = this.callAfterResponseInterceptors(promise, context);
                     promise = this.runInterceptorPhase('afterResponse', context, promise);
-                    promise.resource = config.resourceConstructor;
-                    promise.context = context;
-                    return promise;
+                    promise = this.runInterceptorPhase('afterDeserialize', context, promise);
+                    return extendPromise(promise, {
+                        resource: config.resourceConstructor,
+                        context: context,
+                        abort: abortRequest
+                    });
                 };
 
                 /**
@@ -856,6 +904,16 @@
                         return rejectFn ? rejectFn(rejection, resourceConstructor, context) : $q.reject(rejection);
                     };
                 }
+
+                function extendPromise(promise, attributes) {
+                    var oldThen = promise.then;
+                    promise.then = function (onFulfilled, onRejected, progressBack) {
+                        var chainedPromise = oldThen.apply(this, arguments);
+                        return extendPromise(chainedPromise, attributes);
+                    };
+                    angular.extend(promise, attributes);
+                    return promise;
+                }
             }];
     });
 

data/vendor/assets/javascripts/angularjs/rails/resource/serialization.js

@@ -78,6 +78,7 @@
                     this.preservedAttributes = {};
                     this.customSerializers = {};
                     this.nestedResources = {};
+                    this.polymorphics = {};
                     this.options = angular.extend({excludeByDefault: false}, defaultOptions, options || {});
 
                     if (customizer) {
@@ -159,6 +160,25 @@
                     return this;
                 };
 
+                /**
+                 * Specifies a polymorphic association according to Rails' standards.
+                 * Polymorphic associations have a <code>{name}_id</code> and <code>{name}_type</code> columns in the database.
+                 *
+                 * The <code>{name}_type</code> attribute will specify which resource will be used to serialize and deserialize the data.
+                 *
+                 * @param names... {string} Variable number of name parameters
+                 * @returns {Serializer} this for chaining support
+                 */
+                Serializer.prototype.polymorphic = function () {
+                    var polymorphics = this.polymorphics;
+
+                    angular.forEach(arguments, function(attributeName) {
+                        polymorphics[attributeName] = true;
+                    });
+
+                    return this;
+                };
+
                 /**
                  * Specifies a custom name mapping for an attribute.
                  * On serializing to JSON the jsonName will be used.
@@ -317,10 +337,17 @@
                 /**
                  * Returns a reference to the nested resource that has been specified for the attribute.
                  * @param attributeName The attribute name
+                 * @param data the entire object being serialized
                  * @returns {*} undefined if no nested resource has been specified or a reference to the nested resource class
                  */
-                Serializer.prototype.getNestedResource = function (attributeName) {
-                    return RailsResourceInjector.getDependency(this.nestedResources[attributeName]);
+                Serializer.prototype.getNestedResource = function (attributeName, data) {
+                    var resourceName;
+                    if (!this.polymorphics[attributeName]) {
+                        resourceName = this.nestedResources[attributeName];
+                    } else {
+                        resourceName = data[attributeName + '_type'];
+                    }
+                    return RailsResourceInjector.getDependency(resourceName);
                 };
 
                 /**
@@ -330,10 +357,11 @@
                  * is used.  Custom serializers specified using serializeWith take precedence over the nested resource serializer.
                  *
                  * @param attributeName The attribute name
+                 * @param data the entire object being serialized
                  * @returns {*} undefined if no custom serializer has been specified or an instance of the Serializer
                  */
-                Serializer.prototype.getAttributeSerializer = function (attributeName) {
-                    var resource = this.getNestedResource(attributeName),
+                Serializer.prototype.getAttributeSerializer = function (attributeName, data) {
+                    var resource = this.getNestedResource(attributeName, data),
                         serializer = this.customSerializers[attributeName];
 
                     // custom serializer takes precedence over resource serializer
@@ -376,14 +404,14 @@
                     return result;
                 };
 
-                Serializer.prototype.serializeObject = function(result, data){
+                Serializer.prototype.serializeObject = function(result, data) {
 
 
                     var tthis = this;
                     angular.forEach(data, function (value, key) {
                         // if the value is a function then it can't be serialized to JSON so we'll just skip it
                         if (!angular.isFunction(value)) {
-                            tthis.serializeAttribute(result, key, value);
+                            tthis.serializeAttribute(result, key, value, data);
                         }
                     });
                     return data;
@@ -393,12 +421,13 @@
                  * Transforms an attribute and its value and stores it on the parent data object.  The attribute will be
                  * renamed as needed and the value itself will be serialized as well.
                  *
-                 * @param data The object that the attribute will be added to
+                 * @param result The object that the attribute will be added to
                  * @param attribute The attribute to transform
                  * @param value The current value of the attribute
+                 * @param data the entire object being serialized
                  */
-                Serializer.prototype.serializeAttribute = function (data, attribute, value) {
-                    var serializer = this.getAttributeSerializer(attribute),
+                Serializer.prototype.serializeAttribute = function (result, attribute, value, data) {
+                    var serializer = this.getAttributeSerializer(attribute, data),
                         serializedAttributeName = this.getSerializedAttributeName(attribute);
 
                     // undefined means the attribute should be excluded from serialization
@@ -406,7 +435,7 @@
                         return;
                     }
 
-                    data[serializedAttributeName] = serializer ? serializer.serialize(value) : this.serializeData(value);
+                    result[serializedAttributeName] = serializer ? serializer.serialize(value) : this.serializeData(value);
                 };
 
                 /**
@@ -432,14 +461,14 @@
                                         itemValue = itemValue.call(item, item);
                                     }
 
-                                    self.serializeAttribute(item, key, itemValue);
+                                    self.serializeAttribute(item, key, itemValue, data);
                                 });
                             } else {
                                 if (angular.isFunction(value)) {
                                     value = value.call(data, data);
                                 }
 
-                                self.serializeAttribute(result, key, value);
+                                self.serializeAttribute(result, key, value, data);
                             }
                         });
                     }
@@ -454,9 +483,10 @@
                  *
                  * @param data The object to deserialize
                  * @param Resource (optional) The resource type to deserialize the result into
+                 * @param triggerPhase (optional) Whether to trigger the afterDeserialize phase
                  * @returns {*} A new object or an instance of Resource populated with deserialized data.
                  */
-                Serializer.prototype.deserializeData = function (data, Resource) {
+                Serializer.prototype.deserializeData = function (data, Resource, triggerPhase) {
                     var result = data,
                         self = this;
 
@@ -464,7 +494,7 @@
                         result = [];
 
                         angular.forEach(data, function (value) {
-                            result.push(self.deserializeData(value, Resource));
+                            result.push(self.deserializeData(value, Resource, triggerPhase));
                         });
                     } else if (angular.isObject(data)) {
                         if (angular.isDate(data)) {
@@ -476,19 +506,23 @@
                             result = new Resource.config.resourceConstructor();
                         }
 
-                        this.deserializeObject(result, data);
+                        this.deserializeObject(result, data, triggerPhase);
 
                     }
 
                     return result;
                 };
 
-                Serializer.prototype.deserializeObject = function (result, data) {
+                Serializer.prototype.deserializeObject = function (result, data, triggerPhase) {
 
                     var tthis = this;
                     angular.forEach(data, function (value, key) {
-                        tthis.deserializeAttribute(result, key, value);
+                        tthis.deserializeAttribute(result, key, value, data);
                     });
+                    if (triggerPhase && result.constructor.runInterceptorPhase) {
+                        result.constructor.runInterceptorPhase('afterDeserialize', result);
+                    }
+
                     return data;
                 };
 
@@ -497,11 +531,12 @@
                  * Transforms an attribute and its value and stores it on the parent data object.  The attribute will be
                  * renamed as needed and the value itself will be deserialized as well.
                  *
-                 * @param data The object that the attribute will be added to
+                 * @param result The object that the attribute will be added to
                  * @param attribute The attribute to transform
                  * @param value The current value of the attribute
+                 * @param data the entire object being deserialized
                  */
-                Serializer.prototype.deserializeAttribute = function (data, attribute, value) {
+                Serializer.prototype.deserializeAttribute = function (result, attribute, value, data) {
                     var serializer,
                         NestedResource,
                         attributeName = this.getDeserializedAttributeName(attribute);
@@ -511,14 +546,14 @@
                         return;
                     }
 
-                    serializer = this.getAttributeSerializer(attributeName);
-                    NestedResource = this.getNestedResource(attributeName);
+                    serializer = this.getAttributeSerializer(attributeName, data);
+                    NestedResource = this.getNestedResource(attributeName, data);
 
                     // preserved attributes are assigned unmodified
                     if (this.preservedAttributes[attributeName]) {
-                        data[attributeName] = value;
+                        result[attributeName] = value;
                     } else {
-                        data[attributeName] = serializer ? serializer.deserialize(value, NestedResource) : this.deserializeData(value, NestedResource);
+                        result[attributeName] = serializer ? serializer.deserialize(value, NestedResource, true) : this.deserializeData(value, NestedResource, true);
                     }
                 };
 
@@ -531,11 +566,12 @@
                  *
                  * @param data The object to deserialize
                  * @param Resource (optional) The resource type to deserialize the result into
+                 * @param triggerPhase (optional) Whether to trigger the afterDeserialize phase
                  * @returns {*} A new object or an instance of Resource populated with deserialized data
                  */
-                Serializer.prototype.deserialize = function (data, Resource) {
+                Serializer.prototype.deserialize = function (data, Resource, triggerPhase) {
                     // just calls deserializeValue for now so we can more easily add on custom attribute logic for deserialize too
-                    return this.deserializeData(data, Resource);
+                    return this.deserializeData(data, Resource, triggerPhase);
                 };
 
                 Serializer.prototype.pluralize = function (value) {
@@ -566,4 +602,4 @@
             return railsSerializer;
         }];
     });
-}());
+}());