angularjs-rails-resource 0.1.7 → 0.2.0

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

@@ -0,0 +1,10 @@
+//= require_self
+//= require_tree ./utils
+//= require ./serialization
+//= require ./resource
+
+(function (undefined) {
+    angular.module('rails', ['ng']);
+}());
+
+

data/vendor/assets/javascripts/angularjs/rails/{resource.js → resource/resource.js}

@@ -1,61 +1,4 @@
 (function (undefined) {
-    angular.module('rails', ['ng']);
-
-    function transformObject(data, transform) {
-        var newKey;
-
-        if (data && angular.isObject(data)) {
-            angular.forEach(data, function (value, key) {
-                newKey = transform(key);
-
-                if (newKey !== key) {
-                    data[newKey] = value;
-                    delete data[key];
-                }
-
-                transformObject(value, transform);
-            });
-        }
-    }
-
-    function camelize(key) {
-        if (!angular.isString(key)) {
-            return key;
-        }
-
-        // should this match more than word and digit characters?
-        return key.replace(/_[\w\d]/g, function (match, index, string) {
-            return index === 0 ? match : string.charAt(index + 1).toUpperCase();
-        });
-    }
-
-    function underscore(key) {
-        if (!angular.isString(key)) {
-            return key;
-        }
-
-        return key.replace(/[A-Z]/g, function (match, index) {
-            return index === 0 ? match : '_' + match.toLowerCase();
-        });
-    }
-
-    angular.module('rails').factory('railsFieldRenamingTransformer', function () {
-
-        return function (data) {
-            transformObject(data, underscore);
-            return data;
-        };
-    });
-
-    angular.module('rails').factory('railsFieldRenamingInterceptor', function () {
-        return function (promise) {
-            return promise.then(function (response) {
-                transformObject(response.data, camelize);
-                return response;
-            });
-        };
-    });
-
     angular.module('rails').factory('railsRootWrappingTransformer', function () {
         return function (data, resource) {
             var result = {};
@@ -84,110 +27,128 @@
         };
     });
 
-    angular.module('rails').factory('railsResourceFactory', ['$http', '$q', '$injector', '$interpolate', function ($http, $q, $injector, $interpolate) {
-        // urlBuilder("/path/{{someId}}")(someId: 5) == "/path/5"
-        function urlBuilder(url) {
-            var expression;
-
-            if (angular.isFunction(url)) {
-                return url;
-            }
-
-            if (url.indexOf('{{') === -1) {
-                url = url + '/{{id}}';
-            }
+    angular.module('rails').factory('railsResourceFactory', ['$http', '$q', 'railsUrlBuilder', 'railsSerializer', 'railsRootWrappingTransformer', 'railsRootWrappingInterceptor', 'RailsResourceInjector',
+            function ($http, $q, railsUrlBuilder, railsSerializer, railsRootWrappingTransformer, railsRootWrappingInterceptor, RailsResourceInjector) {
 
-            expression = $interpolate(url);
+        function railsResourceFactory(config) {
+            var transformers = config.requestTransformers,
+                interceptors = config.responseInterceptors;
 
-            return function (params) {
-                url = expression(params);
+            function appendPath(url, path) {
+                if (path) {
+                    if (path[0] !== '/') {
+                        url += '/';
+                    }
 
-                if (url.charAt(url.length - 1) === '/') {
-                    url = url.substr(0, url.length - 1);
+                    url += path;
                 }
 
                 return url;
-            };
-        }
-
-        function railsResourceFactory(config) {
-            var transformers = config.requestTransformers || ['railsRootWrappingTransformer', 'railsFieldRenamingTransformer'],
-                interceptors = config.responseInterceptors || ['railsFieldRenamingInterceptor', 'railsRootWrappingInterceptor'];
+            }
 
             function RailsResource(value) {
-                value || (value = {});
-                var immediatePromise = function(data) {
-                  return {
-                      resource: RailsResource,
-                      response: data,
-                      then: function(callback) {
-                        this.response = callback(this.response, this.resource);
-                        return immediatePromise(this.response);
-                      }
-                    }
-                };
-                var data = RailsResource.callInterceptors(immediatePromise({data: value || {}})).response.data;
-                angular.extend(this, data);
+                if (value) {
+                    var immediatePromise = function(data) {
+                      return {
+                          resource: RailsResource,
+                          response: data,
+                          then: function(callback) {
+                            this.response = callback(this.response, this.resource);
+                            return immediatePromise(this.response);
+                          }
+                        }
+                    };
+
+                    var data = RailsResource.callInterceptors(immediatePromise({data: value})).response.data;
+                    angular.extend(this, data);
+                }
             }
 
             RailsResource.setUrl = function(url) {
-              RailsResource.url = urlBuilder(url);
+              RailsResource.url = railsUrlBuilder(url);
             };
             RailsResource.setUrl(config.url);
-            RailsResource.rootName = config.name;
-            RailsResource.rootPluralName = config.pluralName || config.name + 's';
+
+            RailsResource.enableRootWrapping = config.wrapData === undefined ? true : config.wrapData;
             RailsResource.httpConfig = config.httpConfig || {};
             RailsResource.httpConfig.headers = angular.extend({'Accept': 'application/json', 'Content-Type': 'application/json'}, RailsResource.httpConfig.headers || {});
             RailsResource.requestTransformers = [];
             RailsResource.responseInterceptors = [];
             RailsResource.defaultParams = config.defaultParams;
+            RailsResource.serializer = RailsResourceInjector.createService(config.serializer || railsSerializer());
+            RailsResource.rootName = RailsResource.serializer.underscore(config.name);
+            RailsResource.rootPluralName = RailsResource.serializer.underscore(config.pluralName || RailsResource.serializer.pluralize(config.name));
 
-            // Add a function to run on response / initialize data
-            // model methods and this are not yet available at this point
+            /**
+             * Add a callback to run on response and construction.
+             * @param fn(resource, constructor) - resource is a resource instance, and constructor is the resource class calling the function
+             */
             RailsResource.beforeResponse = function(fn) {
+              var fn = RailsResourceInjector.getDependency(fn);
               RailsResource.responseInterceptors.push(function(promise) {
                 return promise.then(function(response) {
-                  fn(response.data, promise.resource);
-                  return response;
+                    fn(response.data, promise.resource);
+                    return response;
                 });
               });
             };
 
-            // Add a function to run on request data
+            /**
+             * Adds a function to run after serializing the data to send to the server, but before root-wrapping it.
+             * @param fn (data, constructor) - data object is the serialized resource instance, and constructor the resource class calling the function
+             */
             RailsResource.beforeRequest = function(fn) {
+              var fn = RailsResourceInjector.getDependency(fn);
               RailsResource.requestTransformers.push(function(data, resource) {
-                fn(data, resource);
-                return data;
+                return fn(data, resource) || data;
               });
             };
 
             // copied from $HttpProvider to support interceptors being dependency names or anonymous factory functions
             angular.forEach(interceptors, function (interceptor) {
-                RailsResource.responseInterceptors.push(
-                    angular.isString(interceptor)
-                        ? $injector.get(interceptor)
-                        : $injector.invoke(interceptor)
-                );
+                RailsResource.responseInterceptors.push(RailsResourceInjector.getDependency(interceptor));
             });
 
             angular.forEach(transformers, function (transformer) {
-                RailsResource.requestTransformers.push(
-                    angular.isString(transformer)
-                        ? $injector.get(transformer)
-                        : $injector.invoke(transformer)
-                );
+                RailsResource.requestTransformers.push(RailsResourceInjector.getDependency(transformer));
             });
 
+            // transform data for request:
             RailsResource.transformData = function (data) {
+                data = RailsResource.serializer.serialize(data);
+
+                // data is now serialized. call request transformers including beforeRequest
                 angular.forEach(RailsResource.requestTransformers, function (transformer) {
                     data = transformer(data, RailsResource);
                 });
 
+
+                if (RailsResource.enableRootWrapping) {
+                    data = railsRootWrappingTransformer(data, RailsResource);
+                }
+
                 return data;
             };
 
+            // transform data on response:
             RailsResource.callInterceptors = function (promise) {
+                promise = promise.then(function (response) {
+                    // store off the data in case something (like our root unwrapping) assigns data as a new object
+                    response.originalData = response.data;
+                    return response;
+                });
+
+                if (RailsResource.enableRootWrapping) {
+                    promise.resource = RailsResource;
+                    promise = railsRootWrappingInterceptor(promise);
+                }
 
+                promise.then(function (response) {
+                    response.data = RailsResource.serializer.deserialize(response.data, RailsResource);
+                    return response;
+                });
+
+                // data is now deserialized. call response interceptors including beforeResponse
                 angular.forEach(RailsResource.responseInterceptors, function (interceptor) {
                     promise.resource = RailsResource;
                     promise = interceptor(promise);
@@ -197,25 +158,8 @@
             };
 
             RailsResource.processResponse = function (promise) {
-                promise = RailsResource.callInterceptors(promise);
-
-                return promise.then(function (response) {
-                    var result;
-
-                    if (angular.isArray(response.data)) {
-                        result = [];
-
-                        angular.forEach(response.data, function (value) {
-                            result.push(angular.extend(new RailsResource(), value));
-                        });
-                    } else if (angular.isObject(response.data)) {
-                        result = angular.extend(new RailsResource(), response.data);
-
-                    } else {
-                        result = response.data;
-                    }
-
-                    return result;
+                return RailsResource.callInterceptors(promise).then(function (response) {
+                    return response.data;
                 });
             };
 
@@ -255,14 +199,15 @@
              *
              * If the context is a number and the URL string does
              * @param context
+             * @param path {string} (optional) An additional path to append to the URL
              * @return {string}
              */
-            RailsResource.$url = RailsResource.resourceUrl = function (context) {
+            RailsResource.$url = RailsResource.resourceUrl = function (context, path) {
                 if (!angular.isObject(context)) {
                     context = {id: context};
                 }
 
-                return RailsResource.url(context || {});
+                return appendPath(RailsResource.url(context || {}), path);
             };
 
             RailsResource.$get = function (url, queryParams) {
@@ -277,17 +222,17 @@
                 return RailsResource.$get(RailsResource.resourceUrl(context), queryParams);
             };
 
-            RailsResource.prototype.$url = function() {
-                return RailsResource.resourceUrl(this);
+            /**
+             * Returns the URL for this resource.
+             *
+             * @param path {string} (optional) An additional path to append to the URL
+             * @returns {string} The URL for the resource
+             */
+            RailsResource.prototype.$url = function(path) {
+                return appendPath(RailsResource.resourceUrl(this), path);
             };
 
             RailsResource.prototype.processResponse = function (promise) {
-                promise = promise.then(function (response) {
-                    // store off the data in case something (like our root unwrapping) assigns data as a new object
-                    response.originalData = response.data;
-                    return response;
-                });
-
                 promise = RailsResource.callInterceptors(promise);
 
                 return promise.then(angular.bind(this, function (response) {

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

@@ -0,0 +1,471 @@
+(function (undefined) {
+    angular.module('rails').factory('railsSerializer', ['$injector', 'RailsInflector', 'RailsResourceInjector', function ($injector, RailsInflector, RailsResourceInjector) {
+        var defaultOptions = {
+            underscore: RailsInflector.underscore,
+            camelize: RailsInflector.camelize,
+            pluralize: RailsInflector.pluralize,
+            exclusionMatchers: ['$'],
+            excludeByDefault: false
+        };
+
+        function railsSerializer(options, customizer) {
+
+            function Serializer() {
+                if (angular.isFunction(options)) {
+                    customizer = options;
+                    options = {};
+                }
+
+                this.exclusions = {};
+                this.inclusions = {};
+                this.serializeMappings = {};
+                this.deserializeMappings = {};
+                this.customSerializedAttributes = {};
+                this.preservedAttributes = {};
+                this.customSerializers = {};
+                this.nestedResources = {};
+                this.options = angular.extend({}, defaultOptions, options || {});
+
+                if (customizer) {
+                    customizer.call(this, this);
+                }
+            }
+
+            /**
+             * Accepts a variable list of attribute names to exclude from JSON serialization.
+             *
+             * @param attributeNames... {string} Variable number of attribute name parameters
+             * @returns {Serializer} this for chaining support
+             */
+            Serializer.prototype.exclude = function () {
+                var exclusions = this.exclusions;
+
+                angular.forEach(arguments, function (attributeName) {
+                    exclusions[attributeName] = false;
+                });
+
+                return this;
+            };
+
+            /**
+             * Accepts a variable list of attribute names that should be included in JSON serialization.
+             * Using this method will by default exclude all other attributes and only the ones explicitly included using <code>only</code> will be serialized.
+             * @param attributeNames... {string} Variable number of attribute name parameters
+             * @returns {Serializer} this for chaining support
+             */
+            Serializer.prototype.only = function () {
+                var inclusions = this.inclusions;
+                this.options.excludeByDefault = true;
+
+                angular.forEach(arguments, function (attributeName) {
+                    inclusions[attributeName] = true;
+                });
+
+                return this;
+            };
+
+            /**
+             * This is a shortcut for rename that allows you to specify a variable number of attributes that should all be renamed to
+             * <code>{attributeName}_attributes</code> to work with the Rails nested_attributes feature.
+             * @param attributeNames... {string} Variable number of attribute name parameters
+             * @returns {Serializer} this for chaining support
+             */
+            Serializer.prototype.nestedAttribute = function () {
+                var self = this;
+
+                angular.forEach(arguments, function (attributeName) {
+                    self.rename(attributeName, attributeName + '_attributes');
+                });
+
+                return this;
+            };
+
+            /**
+             * Specifies an attribute that is a nested resource within the parent object.
+             * Nested resources do not imply nested attributes, if you want both you still have to specify call <code>nestedAttribute</code> as well.
+             *
+             * A nested resource serves two purposes.  First, it defines the resource that should be used when constructing resources from the server.
+             * Second, it specifies how the nested object should be serialized.
+             *
+             * An optional third parameter <code>serializer</code> is available to override the serialization logic
+             * of the resource in case you need to serialize it differently in multiple contexts.
+             *
+             * @param attributeName {string} The name of the attribute that is a nested resource
+             * @param resource {string | Resource} A reference to the resource that the attribute is a type of.
+             * @param serializer {string | Serializer} (optional) An optional serializer reference to override the nested resource's default serializer
+             * @returns {Serializer} this for chaining support
+             */
+            Serializer.prototype.resource = function (attributeName, resource, serializer) {
+                this.nestedResources[attributeName] = resource;
+
+                if (serializer) {
+                    this.serializeWith(attributeName, serializer);
+                }
+
+                return this;
+            };
+
+            /**
+             * Specifies a custom name mapping for an attribute.
+             * On serializing to JSON the jsonName will be used.
+             * On deserialization, if jsonName is seen then it will be renamed as javascriptName in the resulting resource.
+             *
+             * @param javascriptName {string} The attribute name as it appears in the JavaScript object
+             * @param jsonName {string} The attribute name as it should appear in JSON
+             * @param bidirectional {boolean} (optional) Allows turning off the bidirectional renaming, defaults to true.
+             * @returns {Serializer} this for chaining support
+             */
+            Serializer.prototype.rename = function (javascriptName, jsonName, bidirectional) {
+                this.serializeMappings[javascriptName] = jsonName;
+
+                if (bidirectional || bidirectional === undefined) {
+                    this.deserializeMappings[jsonName] = javascriptName;
+                }
+                return this;
+            };
+
+            /**
+             * Allows custom attribute creation as part of the serialization to JSON.
+             *
+             * @param attributeName {string} The name of the attribute to add
+             * @param value {*} The value to add, if specified as a function then the function will be called during serialization
+             *     and should return the value to add.
+             * @returns {Serializer} this for chaining support
+             */
+            Serializer.prototype.add = function (attributeName, value) {
+                this.customSerializedAttributes[attributeName] = value;
+                return this;
+            };
+
+
+            /**
+             * Allows the attribute to be preserved unmodified in the resulting object.
+             *
+             * @param attributeName {string} The name of the attribute to add
+             * @returns {Serializer} this for chaining support
+             */
+            Serializer.prototype.preserve = function(attributeName) {
+                this.preservedAttributes[attributeName] =  true;
+                return this;
+            };
+
+            /**
+             * Specify a custom serializer to use for an attribute.
+             *
+             * @param attributeName {string} The name of the attribute
+             * @param serializer {string | constructor} A reference to the custom serializer to use for the attribute.
+             * @returns {Serializer} this for chaining support
+             */
+            Serializer.prototype.serializeWith = function (attributeName, serializer) {
+                this.customSerializers[attributeName] = serializer;
+                return this;
+            };
+
+            /**
+             * Determines whether or not an attribute should be excluded.
+             *
+             * If the option excludeByDefault has been set then attributes will default to excluded and will only
+             * be included if they have been included using the "only" customization function.
+             *
+             * If the option excludeByDefault has not been set then attributes must be explicitly excluded using the "exclude"
+             * customization function or must be matched by one of the exclusionMatchers.
+             *
+             * @param attributeName The name of the attribute to check for exclusion
+             * @returns {boolean} true if excluded, false otherwise
+             */
+            Serializer.prototype.isExcludedFromSerialization = function (attributeName) {
+                if ((this.options.excludeByDefault && !this.inclusions.hasOwnProperty(attributeName)) || this.exclusions.hasOwnProperty(attributeName)) {
+                    return true;
+                }
+
+                if (this.options.exclusionMatchers) {
+                    var excluded = false;
+
+                    angular.forEach(this.options.exclusionMatchers, function (matcher) {
+                        if (angular.isString(matcher)) {
+                            excluded = excluded || attributeName.indexOf(matcher) === 0;
+                        } else if (angular.isFunction(matcher)) {
+                            excluded = excluded || matcher.call(undefined, attributeName);
+                        } else if (matcher instanceof RegExp) {
+                            excluded = excluded || matcher.test(attributeName);
+                        }
+                    });
+
+                    return excluded;
+                }
+
+                return false;
+            };
+
+            /**
+             * Remaps the attribute name to the serialized form which includes:
+             *   - checking for exclusion
+             *   - remapping to a custom value specified by the rename customization function
+             *   - underscoring the name
+             *
+             * @param attributeName The current attribute name
+             * @returns {*} undefined if the attribute should be excluded or the mapped attribute name
+             */
+            Serializer.prototype.getSerializedAttributeName = function (attributeName) {
+                var mappedName = this.serializeMappings[attributeName] || attributeName;
+
+                if (this.isExcludedFromSerialization(attributeName) || this.isExcludedFromSerialization(mappedName)) {
+                    return undefined;
+                }
+
+                return this.underscore(mappedName);
+            };
+
+            /**
+             * Determines whether or not an attribute should be excluded from deserialization.
+             *
+             * By default, we do not exclude any attributes from deserialization.
+             *
+             * @param attributeName The name of the attribute to check for exclusion
+             * @returns {boolean} true if excluded, false otherwise
+             */
+            Serializer.prototype.isExcludedFromDeserialization = function (attributeName) {
+                return false;
+            };
+
+            /**
+             * Remaps the attribute name to the deserialized form which includes:
+             *   - camelizing the name
+             *   - checking for exclusion
+             *   - remapping to a custom value specified by the rename customization function
+             *
+             * @param attributeName The current attribute name
+             * @returns {*} undefined if the attribute should be excluded or the mapped attribute name
+             */
+            Serializer.prototype.getDeserializedAttributeName = function (attributeName) {
+                var camelizedName = this.camelize(attributeName);
+
+                camelizedName = this.deserializeMappings[attributeName]
+                    || this.deserializeMappings[camelizedName]
+                    || camelizedName;
+
+                if (this.isExcludedFromDeserialization(attributeName) || this.isExcludedFromDeserialization(camelizedName)) {
+                    return undefined;
+                }
+
+                return camelizedName;
+            };
+
+            /**
+             * Returns a reference to the nested resource that has been specified for the attribute.
+             * @param attributeName The attribute name
+             * @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]);
+            };
+
+            /**
+             * Returns a custom serializer for the attribute if one has been specified.  Custom serializers can be specified
+             * in one of two ways.  The serializeWith customization method allows specifying a custom serializer for any attribute.
+             * Or an attribute could have been specified as a nested resource in which case the nested resource's serializer
+             * is used.  Custom serializers specified using serializeWith take precedence over the nested resource serializer.
+             *
+             * @param attributeName The attribute name
+             * @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 = this.customSerializers[attributeName];
+
+                // custom serializer takes precedence over resource serializer
+                if (serializer) {
+                    return RailsResourceInjector.createService(serializer)
+                } else if (resource) {
+                    return resource.serializer;
+                }
+
+                return undefined;
+            };
+
+
+            /**
+             * Prepares the data for serialization to JSON.
+             *
+             * @param data The data to prepare
+             * @returns {*} A new object or array that is ready for JSON serialization
+             */
+            Serializer.prototype.serializeValue = function (data) {
+                var result = data,
+                    self = this;
+
+                if (angular.isArray(data)) {
+                    result = [];
+
+                    angular.forEach(data, function (value) {
+                        result.push(self.serializeValue(value));
+                    });
+                } else if (angular.isObject(data)) {
+                    if (angular.isDate(data)) {
+                        return data;
+                    }
+                    result = {};
+
+                    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)) {
+                            self.serializeAttribute(result, key, value);
+                        }
+                    });
+                }
+
+                return result;
+            };
+
+            /**
+             * 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 attribute The attribute to transform
+             * @param value The current value of the attribute
+             */
+            Serializer.prototype.serializeAttribute = function (data, attribute, value) {
+                var serializer = this.getAttributeSerializer(attribute),
+                    serializedAttributeName = this.getSerializedAttributeName(attribute);
+
+                // undefined means the attribute should be excluded from serialization
+                if (serializedAttributeName === undefined) {
+                    return;
+                }
+
+                data[serializedAttributeName] = serializer ? serializer.serialize(value) : this.serializeValue(value);
+            };
+
+            /**
+             * Serializes the data by applying various transformations such as:
+             *   - Underscoring attribute names
+             *   - attribute renaming
+             *   - attribute exclusion
+             *   - custom attribute addition
+             *
+             * @param data The data to prepare
+             * @returns {*} A new object or array that is ready for JSON serialization
+             */
+            Serializer.prototype.serialize = function (data) {
+                var result = this.serializeValue(data),
+                    self = this;
+
+                if (angular.isObject(result)) {
+                    angular.forEach(this.customSerializedAttributes, function (value, key) {
+                        if (angular.isFunction(value)) {
+                            value = value.call(data, data);
+                        }
+
+                        self.serializeAttribute(result, key, value);
+                    });
+                }
+
+                return result;
+            };
+
+            /**
+             * Iterates over the data deserializing each entry on arrays and each key/value on objects.
+             *
+             * @param data The object to deserialize
+             * @param Resource (optional) The resource type to deserialize the result into
+             * @returns {*} A new object or an instance of Resource populated with deserialized data.
+             */
+            Serializer.prototype.deserializeValue = function (data, Resource) {
+                var result = data,
+                    self = this;
+
+                if (angular.isArray(data)) {
+                    result = [];
+
+                    angular.forEach(data, function (value) {
+                        result.push(self.deserializeValue(value, Resource));
+                    });
+                } else if (angular.isObject(data)) {
+                    result = {};
+
+                    if (Resource) {
+                        result = new Resource();
+                    }
+
+                    angular.forEach(data, function (value, key) {
+                        self.deserializeAttribute(result, key, value);
+                    });
+                }
+
+                return result;
+            };
+
+            /**
+             * 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 attribute The attribute to transform
+             * @param value The current value of the attribute
+             */
+            Serializer.prototype.deserializeAttribute = function (data, attribute, value) {
+                var serializer,
+                    NestedResource,
+                    attributeName = this.getDeserializedAttributeName(attribute);
+
+                // undefined means the attribute should be excluded from serialization
+                if (attributeName === undefined) {
+                    return;
+                }
+
+                serializer = this.getAttributeSerializer(attributeName);
+                NestedResource = this.getNestedResource(attributeName);
+
+                // preserved attributes are assigned unmodified
+                if (this.preservedAttributes[attributeName]) {
+                    data[attributeName] = value;
+                } else {
+                    data[attributeName] = serializer ? serializer.deserialize(value, NestedResource) : this.deserializeValue(value, NestedResource);
+                }
+            };
+
+            /**
+             * Deserializes the data by applying various transformations such as:
+             *   - Camelizing attribute names
+             *   - attribute renaming
+             *   - attribute exclusion
+             *   - nested resource creation
+             *
+             * @param data The object to deserialize
+             * @param Resource (optional) The resource type to deserialize the result into
+             * @returns {*} A new object or an instance of Resource populated with deserialized data
+             */
+            Serializer.prototype.deserialize = function (data, Resource) {
+                // just calls deserializeValue for now so we can more easily add on custom attribute logic for deserialize too
+                return this.deserializeValue(data, Resource);
+            };
+
+            Serializer.prototype.pluralize = function (value) {
+                if (this.options.pluralize) {
+                    return this.options.pluralize(value);
+                }
+                return value;
+            };
+
+            Serializer.prototype.underscore = function (value) {
+                if (this.options.underscore) {
+                    return this.options.underscore(value);
+                }
+                return value;
+            };
+
+            Serializer.prototype.camelize = function (value) {
+                if (this.options.camelize) {
+                    return this.options.camelize(value);
+                }
+                return value;
+            }
+
+            return Serializer;
+        }
+
+        railsSerializer.defaultOptions = defaultOptions;
+        return railsSerializer;
+    }]);
+}());