angularjs-rails-resource 2.3.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64cc55475c184d63ac0829b883be99a9aefc079c
-  data.tar.gz: 471381f4a57eeb8020860913e631f9a0ca4825f9
+  metadata.gz: 02ee284de9ae42fafae6f2d8f5e102fddeb1e511
+  data.tar.gz: 1e51b537318f682dcc4ca6ab6fabf12a330268f6
 SHA512:
-  metadata.gz: a57e02d6c154624b87ffe8ab1a73ff82a33ff1a8735350ca26fea790a377f3d1f020ba2d2568ab8433d2f86f1c0f575540ee4d3987955986e6a9545abf7a8f06
-  data.tar.gz: db534a8034b262cd3cf43818d7c2f83bc739fc4020cf36b41520365f853954bae5d1773939a1def2e41ba1f00c12f349875b5b90b6f5ac78f59ea377f93099ef
+  metadata.gz: 2690f964e3f318dc91bc22185a221754f764c802c1fc2c6956c585300b14fef3c12b5ba7ccb39b506c6cad29ee670ede7480c3b3fc7627f4f8867f8c610f5833
+  data.tar.gz: 027b2c3e8ae30b98710f392cfa0c890128032aa851e132e8f0cf7f688d384b6f650adc183fec6b6fbdffccc7cf2479d95688cb184051d3c68966d3b96bec06b5

data/.gitignore

@@ -19,5 +19,6 @@ test_out
 atlassian-ide-plugin.xml
 node_modules
 build/
+dist/*.zip
 .idea/
 

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+<a name="2.3.1"></a>
+# 2.3.1
+## Bug Fixes
+- Updated bower and NPM distributions to fix invalid main reference for NPM package
+
 <a name="2.3.0"></a>
 # 2.3.0
 ## Features

data/Gruntfile.js

@@ -22,7 +22,7 @@ module.exports = function(grunt) {
     },
 
     dirs: {
-      dest: 'build'
+      dest: 'dist'
     },
 
     clean: ['<%= dirs.dest %>'],
@@ -82,11 +82,6 @@ module.exports = function(grunt) {
       }
     },
 
-    watch: {
-      files: ['<%= jshint.files %>'],
-      tasks: ['jshint']
-    },
-
     bump: {
       options: {
         files: ['package.json', 'bower.json'],
@@ -99,7 +94,6 @@ module.exports = function(grunt) {
 
   grunt.loadNpmTasks('grunt-contrib-uglify');
   grunt.loadNpmTasks('grunt-contrib-jshint');
-  grunt.loadNpmTasks('grunt-contrib-watch');
   grunt.loadNpmTasks('grunt-contrib-concat');
   grunt.loadNpmTasks('grunt-contrib-copy');
   grunt.loadNpmTasks('grunt-contrib-clean');

data/bower.json

@@ -1,27 +1,28 @@
 {
   "name": "angularjs-rails-resource",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "main": "angularjs-rails-resource.js",
   "description": "A resource factory inspired by $resource from AngularJS",
   "repository": {
     "type": "git",
-    "url": "https://github.com/FineLinePrototyping/dist-angularjs-rails-resource.git"
+    "url": "https://github.com/FineLinePrototyping/angularjs-rails-resource.git"
   },
   "dependencies": {
     "angular": "^1.3"
   },
   "ignore": [
-    "node_modules",
+    "**/.*",
+    "angularjs-rails-resource.gemspec",
+    "changelog.js",
     "Gemfile",
     "Gruntfile.js",
     "karma.conf.js",
+    "package-lock.json",
     "package.json",
     "Rakefile",
-    "angularjs-rails-resource.gemspec",
     "test",
     "vendor",
     "lib",
-    "*.zip",
     ".travis.yml",
     ".gitignore"
   ]

data/dist/angularjs-rails-resource.js

@@ -0,0 +1,1703 @@
+/**
+ * A resource factory inspired by $resource from AngularJS
+ * @version v2.3.1 - 2018-02-11
+ * @link https://github.com/FineLinePrototyping/angularjs-rails-resource.git
+ * @author 
+ */
+
+(function (undefined) {
+    angular.module('rails', ['ng']);
+}());
+
+
+
+(function (undefined) {
+    angular.module('rails').factory('RailsInflector', function() {
+        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;
+            }
+
+            // TODO match the latest logic from Active Support
+            return key.replace(/[A-Z]/g, function (match, index) {
+                return index === 0 ? match : '_' + match.toLowerCase();
+            });
+        }
+
+        function pluralize(value) {
+            // TODO match Active Support
+            return value + 's';
+        }
+
+        return {
+            camelize: camelize,
+            underscore: underscore,
+            pluralize: pluralize
+        };
+    });
+}());
+(function (undefined) {
+    angular.module('rails').factory('RailsResourceInjector', ['$injector', function($injector) {
+        /**
+         * Allow dependencies to be referenced by name or instance.  If referenced by name AngularJS $injector
+         * is used to retrieve the dependency.
+         *
+         * @param dependency (string | function) The dependency to retrieve
+         * @returns {*} The dependency
+         */
+        function getDependency(dependency) {
+            if (dependency) {
+                return angular.isString(dependency) ? $injector.get(dependency) : dependency;
+            }
+
+            return undefined;
+        }
+
+        /**
+         * Looks up and instantiates an instance of the requested service.  If the service is not a string then it is
+         * assumed to be a constructor function.
+         *
+         * @param {String|function|Object} service  The service to instantiate
+         * @returns {*} A new instance of the requested service
+         */
+        function createService(service) {
+            if (service) {
+                return $injector.instantiate(getDependency(service));
+            }
+
+            return undefined;
+        }
+
+        /**
+         * Looks up and instantiates an instance of the requested service if .
+         * @param {String|function|Object} service The service to instantiate
+         * @returns {*}
+         */
+        function getService(service) {
+            // strings and functions are not considered objects by angular.isObject()
+            if (angular.isObject(service)) {
+                return service;
+            } else if (service) {
+                return createService(service);
+            }
+
+            return undefined;
+        }
+
+        return {
+            createService: createService,
+            getService: getService,
+            getDependency: getDependency
+        };
+    }]);
+}());
+/**
+ * @ngdoc function
+ * @name rails.railsUrlBuilder
+ * @function
+ * @requires $interpolate
+ *
+ * @description
+ *
+ * Compiles a URL template string into an interpolation function using $interpolate.  If no interpolation bindings
+ * found then {{id}} is appended to the url string.
+ *
+   <pre>
+       expect(railsUrlBuilder('/books')()).toEqual('/books')
+       expect(railsUrlBuilder('/books')({id: 1})).toEqual('/books/1')
+       expect(railsUrlBuilder('/authors/{{authorId}}/books/{{id}}')({id: 1, authorId: 2})).toEqual('/authors/2/books/1')
+   </pre>
+ *
+ * If the $interpolate startSymbol and endSymbol have been customized those values should be used instead of {{ and }}
+ *
+ * @param {string|function} url If the url is a function then that function is returned.  Otherwise the url string
+ *    is passed to $interpolate as an expression.
+ *
+ * @returns {function(context)} As stated by $interpolate documentation:
+ *    An interpolation function which is used to compute the interpolated
+ *    string. The function has these parameters:
+ *
+ *    * `context`: an object against which any expressions embedded in the strings are evaluated
+ *      against.
+ *
+ */
+(function (undefined) {
+    angular.module('rails').factory('railsUrlBuilder', ['$interpolate', function($interpolate) {
+        return function (config) {
+            var url = config.url,
+              idAttribute = config.idAttribute,
+              expression;
+
+            if (angular.isFunction(url) || angular.isUndefined(url)) {
+                return url;
+            }
+
+            if (!config.singular && url.indexOf($interpolate.startSymbol()) === -1) {
+                url = url + '/' + $interpolate.startSymbol() + idAttribute + $interpolate.endSymbol();
+            }
+
+            expression = $interpolate(url);
+
+            return function (params) {
+                url = expression(params);
+
+                if (url.charAt(url.length - 1) === '/') {
+                    url = url.substr(0, url.length - 1);
+                }
+
+                return url;
+            };
+        };
+    }]);
+}());
+
+(function (undefined) {
+    angular.module('rails').provider('railsSerializer', function() {
+        var defaultOptions = {
+            underscore: undefined,
+            camelize: undefined,
+            pluralize: undefined,
+            exclusionMatchers: []
+        };
+
+        /**
+         * Configures the underscore method used by the serializer.  If not defined then <code>RailsInflector.underscore</code>
+         * will be used.
+         *
+         * @param {function(string):string} fn The function to use for underscore conversion
+         * @returns {railsSerializerProvider} The provider for chaining
+         */
+        this.underscore = function(fn) {
+            defaultOptions.underscore = fn;
+            return this;
+        };
+
+        /**
+         * Configures the camelize method used by the serializer.  If not defined then <code>RailsInflector.camelize</code>
+         * will be used.
+         *
+         * @param {function(string):string} fn The function to use for camelize conversion
+         * @returns {railsSerializerProvider} The provider for chaining
+         */
+        this.camelize = function(fn) {
+            defaultOptions.camelize = fn;
+            return this;
+        };
+
+        /**
+         * Configures the pluralize method used by the serializer.  If not defined then <code>RailsInflector.pluralize</code>
+         * will be used.
+         *
+         * @param {function(string):string} fn The function to use for pluralizing strings.
+         * @returns {railsSerializerProvider} The provider for chaining
+         */
+        this.pluralize = function(fn) {
+            defaultOptions.pluralize = fn;
+            return this;
+        };
+
+        /**
+         * Configures the array exclusion matchers by the serializer.  Exclusion matchers can be one of the following:
+         * * string - Defines a prefix that is used to test for exclusion
+         * * RegExp - A custom regular expression that is tested against the attribute name
+         * * function - A custom function that accepts a string argument and returns a boolean with true indicating exclusion.
+         *
+         * @param {Array.<string|function(string):boolean|RegExp} exclusions An array of exclusion matchers
+         * @returns {railsSerializerProvider} The provider for chaining
+         */
+        this.exclusionMatchers = function(exclusions) {
+            defaultOptions.exclusionMatchers = exclusions;
+            return this;
+        };
+
+        this.$get = ['$injector', 'RailsInflector', 'RailsResourceInjector', function ($injector, RailsInflector, RailsResourceInjector) {
+            defaultOptions.underscore = defaultOptions.underscore || RailsInflector.underscore;
+            defaultOptions.camelize = defaultOptions.camelize || RailsInflector.camelize;
+            defaultOptions.pluralize = defaultOptions.pluralize || RailsInflector.pluralize;
+
+            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.polymorphics = {};
+                    this.options = angular.extend({excludeByDefault: false}, 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 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.
+                 * 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 | function} 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;
+
+                    var mappedNameExcluded = this.isExcludedFromSerialization(mappedName),
+                        attributeNameExcluded = this.isExcludedFromSerialization(attributeName);
+
+                    if(this.options.excludeByDefault) {
+                        if(mappedNameExcluded && attributeNameExcluded) {
+                            return undefined;
+                        }
+                    } else {
+                        if (mappedNameExcluded || attributeNameExcluded) {
+                            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
+                 * @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, data) {
+                    var resourceName;
+                    if (!this.polymorphics[attributeName]) {
+                        resourceName = this.nestedResources[attributeName];
+                    } else {
+                        resourceName = data[attributeName + '_type'];
+                    }
+                    return RailsResourceInjector.getDependency(resourceName);
+                };
+
+                /**
+                 * 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
+                 * @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, data) {
+                    var resource = this.getNestedResource(attributeName, data),
+                        serializer = this.customSerializers[attributeName];
+
+                    // custom serializer takes precedence over resource serializer
+                    if (serializer) {
+                        return RailsResourceInjector.createService(serializer);
+                    } else if (resource) {
+                        return resource.config.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.serializeData = function (data) {
+                    var result = data,
+                        self = this;
+
+                    if (angular.isArray(data)) {
+                        result = [];
+
+                        angular.forEach(data, function (value) {
+                            result.push(self.serializeData(value));
+                        });
+                    } else if (angular.isObject(data)) {
+                        if (angular.isDate(data)) {
+                            return data;
+                        }
+                        result = {};
+
+                        this.serializeObject(result, data);
+
+                    }
+
+                    return result;
+                };
+
+                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, data);
+                        }
+                    });
+                    return data;
+                };
+
+                /**
+                 * 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 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 (result, attribute, value, data) {
+                    var serializer = this.getAttributeSerializer(attribute, data),
+                        serializedAttributeName = this.getSerializedAttributeName(attribute);
+
+                    // undefined means the attribute should be excluded from serialization
+                    if (serializedAttributeName === undefined) {
+                        return;
+                    }
+
+                    result[serializedAttributeName] = serializer ? serializer.serialize(value) : this.serializeData(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 = angular.copy(data),
+                        self = this;
+
+                    if (angular.isObject(result)) {
+                        angular.forEach(this.customSerializedAttributes, function (value, key) {
+                            if (angular.isArray(result)) {
+                                angular.forEach(result, function (item, index) {
+                                    var itemValue = value;
+                                    if (angular.isFunction(value)) {
+                                        itemValue = itemValue.call(item, item);
+                                    }
+
+                                    self.serializeAttribute(item, key, itemValue, data);
+                                });
+                            } else {
+                                if (angular.isFunction(value)) {
+                                    value = value.call(data, data);
+                                }
+
+                                self.serializeAttribute(result, key, value, data);
+                            }
+                        });
+                    }
+
+                    result = this.serializeData(result);
+
+                    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
+                 * @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, triggerPhase) {
+                    var result = data,
+                        self = this;
+
+                    if (angular.isArray(data)) {
+                        result = [];
+
+                        angular.forEach(data, function (value) {
+                            result.push(self.deserializeData(value, Resource, triggerPhase));
+                        });
+                    } else if (angular.isObject(data)) {
+                        if (angular.isDate(data)) {
+                            return data;
+                        }
+                        result = {};
+
+                        if (Resource) {
+                            result = new Resource.config.resourceConstructor();
+                        }
+
+                        this.deserializeObject(result, data, triggerPhase);
+
+                    }
+
+                    return result;
+                };
+
+                Serializer.prototype.deserializeObject = function (result, data, triggerPhase) {
+
+                    var tthis = this;
+                    angular.forEach(data, function (value, key) {
+                        tthis.deserializeAttribute(result, key, value, data);
+                    });
+                    if (triggerPhase && result.constructor.runInterceptorPhase) {
+                        result.constructor.runInterceptorPhase('afterDeserialize', result);
+                    }
+
+                    return data;
+                };
+
+
+                /**
+                 * 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 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 (result, attribute, value, data) {
+                    var serializer,
+                        NestedResource,
+                        attributeName = this.getDeserializedAttributeName(attribute);
+
+                    // undefined means the attribute should be excluded from serialization
+                    if (attributeName === undefined) {
+                        return;
+                    }
+
+                    serializer = this.getAttributeSerializer(attributeName, data);
+                    NestedResource = this.getNestedResource(attributeName, data);
+
+                    // preserved attributes are assigned unmodified
+                    if (this.preservedAttributes[attributeName]) {
+                        result[attributeName] = value;
+                    } else {
+                        result[attributeName] = serializer ? serializer.deserialize(value, NestedResource, true) : this.deserializeData(value, NestedResource, true);
+                    }
+                };
+
+                /**
+                 * 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
+                 * @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, triggerPhase) {
+                    // just calls deserializeValue for now so we can more easily add on custom attribute logic for deserialize too
+                    return this.deserializeData(data, Resource, triggerPhase);
+                };
+
+                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;
+        }];
+    });
+}());
+
+(function (undefined) {
+    angular.module('rails').factory('railsRootWrapper', function () {
+        return {
+            wrap: function (data, resource) {
+                var result = {};
+                result[angular.isArray(data) ? resource.config.pluralName : resource.config.name] = data;
+                return result;
+            },
+            unwrap: function (response, resource, isObject) {
+                if (response.data && response.data.hasOwnProperty(resource.config.name)) {
+                    response.data = response.data[resource.config.name];
+                } else if (response.data && response.data.hasOwnProperty(resource.config.pluralName) && !isObject) {
+                    response.data = response.data[resource.config.pluralName];
+                }
+
+                return response;
+            }
+        };
+    });
+
+    angular.module('rails').provider('RailsResource', function () {
+        var defaultOptions = {
+            rootWrapping: true,
+            updateMethod: 'put',
+            httpConfig: {},
+            defaultParams: undefined,
+            underscoreParams: true,
+            fullResponse: false,
+            singular: false,
+            extensions: []
+        };
+
+        /**
+         * Enables or disables root wrapping by default for RailsResources
+         * Defaults to true.
+         * @param {boolean} value true to enable root wrapping, false to disable
+         * @returns {RailsResourceProvider} The provider instance
+         */
+        this.rootWrapping = function (value) {
+            defaultOptions.rootWrapping = value;
+            return this;
+        };
+
+        /**
+         * Configures what HTTP operation should be used for update by default for RailsResources.
+         * Defaults to 'put'
+         * @param value
+         * @returns {RailsResourceProvider} The provider instance
+         */
+        this.updateMethod = function (value) {
+            defaultOptions.updateMethod = value;
+            return this;
+        };
+
+        /**
+         * Configures default HTTP configuration operations for all RailsResources.
+         *
+         * @param {Object} value See $http for available configuration options.
+         * @returns {RailsResourceProvider} The provider instance
+         */
+        this.httpConfig = function (value) {
+            defaultOptions.httpConfig = value;
+            return this;
+        };
+
+        /**
+         * Configures default HTTP query parameters for all RailsResources.
+         *
+         * @param {Object} value Object of key/value pairs representing the HTTP query parameters for all HTTP operations.
+         * @returns {RailsResourceProvider} The provider instance
+         */
+        this.defaultParams = function (value) {
+            defaultOptions.defaultParams = value;
+            return this;
+        };
+
+        /**
+         * Configures whether or not underscore query parameters
+         * @param {boolean} value true to underscore.  Defaults to true.
+         * @returns {RailsResourceProvider} The provider instance
+         */
+        this.underscoreParams = function (value) {
+            defaultOptions.underscoreParams = value;
+            return this;
+        };
+
+        /**
+         * Configures whether the full response from $http is returned or just the result data.
+         * @param {boolean} value true to return full $http response.  Defaults to false.
+         * @returns {RailsResourceProvider} The provider instance
+         */
+        this.fullResponse = function (value) {
+            defaultOptions.fullResponse = value;
+            return this;
+        };
+
+        /**
+         * List of RailsResource extensions to include by default.
+         *
+         * @param {...string} extensions One or more extension names to include
+         * @returns {*}
+         */
+        this.extensions = function () {
+            defaultOptions.extensions = [];
+            angular.forEach(arguments, function (value) {
+                defaultOptions.extensions = defaultOptions.extensions.concat(value);
+            });
+            return this;
+        };
+
+        this.$get = ['$http', '$q', '$timeout', 'railsUrlBuilder', 'railsSerializer', 'railsRootWrapper', 'RailsResourceInjector',
+            function ($http, $q, $timeout, railsUrlBuilder, railsSerializer, railsRootWrapper, RailsResourceInjector) {
+
+                function RailsResource(value) {
+                    if (value) {
+                        var response = this.constructor.deserialize({data: value});
+                        if (this.constructor.config.rootWrapping) {
+                            response = railsRootWrapper.unwrap(response, this.constructor, true);
+                        }
+                        angular.extend(this, response.data);
+                        this.constructor.runInterceptorPhase('afterDeserialize', this);
+                    }
+                }
+
+                /**
+                 * Extends the RailsResource to the child constructor function making the child constructor a subclass of
+                 * RailsResource.  This is modeled off of CoffeeScript's class extend function.  All RailsResource
+                 * class properties defined are copied to the child class and the child's prototype chain is configured
+                 * to allow instances of the child class to have all of the instance methods of RailsResource.
+                 *
+                 * Like CoffeeScript, a __super__ property is set on the child class to the parent resource's prototype chain.
+                 * This is done to allow subclasses to extend the functionality of instance methods and still
+                 * call back to the original method using:
+                 *
+                 *     Class.__super__.method.apply(this, arguments);
+                 *
+                 * @param {function} child Child constructor function
+                 * @returns {function} Child constructor function
+                 */
+                RailsResource.extendTo = function (child) {
+                    angular.forEach(this, function (value, key) {
+                        child[key] = value;
+                    });
+
+                    if (angular.isArray(this.$modules)) {
+                        child.$modules = this.$modules.slice(0);
+                    }
+
+                    function ctor() {
+                        this.constructor = child;
+                    }
+
+                    ctor.prototype = this.prototype;
+                    child.prototype = new ctor();
+                    child.__super__ = this.prototype;
+                    return child;
+                };
+
+                /**
+                 * Copies a mixin's properties to the resource.
+                 *
+                 * If module is a String then we it will be loaded using Angular's dependency injection.  If the name is
+                 * not valid then Angular will throw an error.
+                 *
+                 * @param {...String|function|Object} mixins The mixin or name of the mixin to add.
+                 * @returns {RailsResource} this
+                 */
+                RailsResource.extend = function () {
+                    angular.forEach(arguments, function (mixin) {
+                        addMixin(this, this, mixin, function (Resource, mixin) {
+                            if (angular.isFunction(mixin.extended)) {
+                                mixin.extended(Resource);
+                            }
+                        });
+                    }, this);
+
+                    return this;
+                };
+
+                /**
+                 * Copies a mixin's properties to the resource's prototype chain.
+                 *
+                 * If module is a String then we it will be loaded using Angular's dependency injection.  If the name is
+                 * not valid then Angular will throw an error.
+                 *
+                 * @param {...String|function|Object} mixins The mixin or name of the mixin to add
+                 * @returns {RailsResource} this
+                 */
+                RailsResource.include = function () {
+                    angular.forEach(arguments, function (mixin) {
+                        addMixin(this, this.prototype, mixin, function (Resource, mixin) {
+                            if (angular.isFunction(mixin.included)) {
+                                mixin.included(Resource);
+                            }
+                        });
+                    }, this);
+
+                    return this;
+                };
+
+                /**
+                 * Sets configuration options.  This method may be called multiple times to set additional options or to
+                 * override previous values (such as the case with inherited resources).
+                 * @param cfg
+                 */
+                RailsResource.configure = function (cfg) {
+                    cfg = cfg || {};
+
+                    if (this.config) {
+                        cfg = angular.extend({}, this.config, cfg);
+                    }
+
+                    this.config = {};
+                    this.config.idAttribute = cfg.idAttribute || 'id';
+                    this.config.url = cfg.url;
+                    this.config.rootWrapping = booleanParam(cfg.rootWrapping, defaultOptions.rootWrapping); // using undefined check because config.rootWrapping || true would be true when config.rootWrapping === false
+                    this.config.httpConfig = cfg.httpConfig || defaultOptions.httpConfig;
+                    this.config.httpConfig.headers = angular.extend({'Accept': 'application/json', 'Content-Type': 'application/json'}, this.config.httpConfig.headers || {});
+                    this.config.defaultParams = cfg.defaultParams || defaultOptions.defaultParams;
+                    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) : [];
+                    this.config.afterResponseInterceptors = cfg.afterResponseInterceptors ? cfg.afterResponseInterceptors.slice(0) : [];
+                    this.config.interceptors = cfg.interceptors ? cfg.interceptors.slice(0) : [];
+
+                    this.config.serializer = RailsResourceInjector.getService(cfg.serializer || railsSerializer());
+
+                    this.config.name = this.config.serializer.underscore(cfg.name);
+
+                    // we don't want to turn undefined name into "undefineds" then the plural name won't update when the name is set
+                    if (this.config.name) {
+                        this.config.pluralName = this.config.serializer.underscore(cfg.pluralName || this.config.serializer.pluralize(this.config.name));
+                    }
+
+                    this.config.urlBuilder = railsUrlBuilder(this.config);
+                    this.config.resourceConstructor = this;
+
+                    this.extend.apply(this, loadExtensions((cfg.extensions || []).concat(defaultOptions.extensions)));
+
+                    angular.forEach(this.$mixins, function (mixin) {
+                        if (angular.isFunction(mixin.configure)) {
+                            mixin.configure(this.config, cfg);
+                        }
+                    }, this);
+
+                    return this.config;
+                };
+
+                /**
+                 * Configures the URL for the resource.
+                 * @param {String|function} url The url string or function.
+                 */
+                RailsResource.setUrl = function (url) {
+                    this.configure({url: url});
+                };
+
+                RailsResource.buildUrl = function (context) {
+                    return this.config.urlBuilder(context);
+                };
+
+                /**
+                 * Interceptors utilize $q promises to allow for both synchronous and asynchronous processing during
+                 * a request / response cycle.
+                 *
+                 * Interceptors can be added as a service factory name or as an object with properties matching one
+                 * or more of the phases.  Each property should have a value of a function to be called during that phase.
+                 *
+                 * There are multiple phases for both request and response.  In addition, each phase has a corresponding
+                 * error phase to handle promise rejections.
+                 *
+                 * Each request phase interceptor is called with the $http config object, the resource constructor, and if
+                 * applicable the resource instance.  The interceptor is free to modify the config or create a new one.
+                 * The interceptor function must return a valid $http config or a promise that will eventually resolve
+                 * to a config object.
+                 *
+                 * The valid request phases are:
+                 *
+                 * * beforeRequest: Interceptors are called prior to any data serialization or root wrapping.
+                 * * beforeRequestError: Interceptors get called when a previous interceptor threw an error or
+                 *      resolved with a rejection.
+                 * * beforeRequestWrapping: Interceptors are called after data serialization but before root wrapping.
+                 * * beforeRequestWrappingError: Interceptors get called when a previous interceptor threw an error or
+                 *      resolved with a rejection.
+                 * * request:  Interceptors are called after any data serialization and root wrapping have been performed.
+                 * * requestError: Interceptors get called when a previous interceptor threw an error or
+                 *      resolved with a rejection.
+                 *
+                 * The beforeResponse and response interceptors are called with the $http response object,
+                 * the resource constructor, and if applicable the resource instance.  The afterResponse interceptors
+                 * are typically called with the response data instead of the full response object unless the config option
+                 * fullResponse has been set to true.  Like the request interceptor callbacks the response callbacks can
+                 * manipulate the data or return new data.  The interceptor function must return
+                 *
+                 * The valid response phases are:
+                 *
+                 * * beforeResponse: Interceptors are called prior to any data processing.
+                 * * beforeResponseError: Interceptors get called when a previous interceptor threw an error or
+                 *      resolved with a rejection.
+                 * * beforeResponseDeserialize: Interceptors are called after root unwrapping but prior to data deserializing.
+                 * * beforeResponseDeserializeError: Interceptors get called when a previous interceptor threw an error or
+                 *      resolved with a rejection.
+                 * * response:  Interceptors are called after the data has been deserialized and root unwrapped but
+                 *      prior to the data being copied to the resource instance if applicable.
+                 * * responseError: Interceptors get called when a previous interceptor threw an error or
+                 *      resolved with a rejection.
+                 * * afterResponse:  Interceptors are called at the very end of the response chain after all processing
+                 *      has been completed.  The value of the first parameter is one of the following:
+                 *       - resource instance: When fullResponse is false and the operation was called on a resource instance.
+                 *       - response data: When fullResponse is false and the operation was called on the resource class.
+                 *       - $http response: When fullResponse is true
+                 * * 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) {
+                    this.config.interceptors.push(interceptor);
+                };
+
+                /**
+                 * Adds an interceptor callback function for the specified phase.
+                 * @param {String} phase The interceptor phase, one of:
+                 *      beforeRequest, request, beforeResponse, response, afterResponse, afterDeserialize
+                 * @param fn The function to call.
+                 */
+                RailsResource.intercept = function (phase, fn) {
+                    var interceptor = {};
+                    fn = RailsResourceInjector.getDependency(fn);
+
+                    interceptor[phase] = function (value, resourceConstructor, context) {
+                        return fn(value, resourceConstructor, context) || value;
+                    };
+
+                    this.addInterceptor(interceptor);
+                };
+
+                /**
+                 * Adds interceptor on 'beforeRequest' phase.
+                 * @param fn(httpConfig, constructor, context) - httpConfig is the config object to pass to $http,
+                 *      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.interceptBeforeRequest = function (fn) {
+                    this.intercept('beforeRequest', fn);
+                };
+
+                /**
+                 * Adds interceptor on 'beforeRequestWrapping' phase.
+                 * @param fn(httpConfig, constructor, context) - httpConfig is the config object to pass to $http,
+                 *      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.interceptBeforeRequestWrapping = function (fn) {
+                    this.intercept('beforeRequestWrapping', fn);
+                };
+
+                /**
+                 * Adds interceptor on 'request' phase.
+                 * @param fn(httpConfig, constructor, context) - httpConfig is the config object to pass to $http,
+                 *      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.interceptRequest = function (fn) {
+                    this.intercept('request', fn);
+                };
+
+                /**
+                 * Adds interceptor on 'beforeResponse' 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.interceptBeforeResponse = function (fn) {
+                    this.intercept('beforeResponse', fn);
+                };
+
+                /**
+                 * Adds interceptor on 'beforeResponseDeserialize' 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.interceptBeforeResponseDeserialize = function (fn) {
+                    this.intercept('beforeResponseDeserialize', fn);
+                };
+
+                /**
+                 * Adds interceptor on 'response' 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.interceptResponse = function (fn) {
+                    this.intercept('response', fn);
+                };
+
+                /**
+                 * Adds interceptor on 'afterResponse' 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.interceptAfterResponse = function (fn) {
+                    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.
+                 * @deprecated since version 1.0.0, use interceptResponse instead
+                 * @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.beforeResponse = function (fn) {
+                    fn = RailsResourceInjector.getDependency(fn);
+                    this.interceptResponse(function (response, resource, context) {
+                        fn(response.data, resource.config.resourceConstructor, context);
+                        return response;
+                    });
+                };
+
+                /**
+                 * Deprecated, see interceptors
+                 * Add a callback to run after response has been processed.  These callbacks are not called on object construction.
+                 * @deprecated since version 1.0.0, use interceptAfterResponse instead
+                 * @param fn(response data, constructor) - response data is either the resource instance returned or an array of resource instances and constructor is the resource class calling the function
+                 */
+                RailsResource.afterResponse = function (fn) {
+                    fn = RailsResourceInjector.getDependency(fn);
+                    this.interceptAfterResponse(function (response, resource, context) {
+                        fn(response, resource.config.resourceConstructor, context);
+                        return response;
+                    });
+                };
+
+                /**
+                 * Deprecated, see interceptors
+                 * Adds a function to run after serializing the data to send to the server, but before root-wrapping it.
+                 * @deprecated since version 1.0.0, use interceptBeforeRequestWrapping instead
+                 * @param fn (data, constructor) - data object is the serialized resource instance, and constructor the resource class calling the function
+                 */
+                RailsResource.beforeRequest = function (fn) {
+                    fn = RailsResourceInjector.getDependency(fn);
+                    this.interceptBeforeRequestWrapping(function (httpConfig, resource) {
+                        httpConfig.data = fn(httpConfig.data, resource.config.resourceConstructor) || httpConfig.data;
+                        return httpConfig;
+                    });
+                };
+
+                RailsResource.serialize = function (httpConfig) {
+                    if (httpConfig.data) {
+                        httpConfig.data = this.config.serializer.serialize(httpConfig.data);
+                    }
+
+                    return httpConfig;
+                };
+
+                /**
+                 * Deserializes the response data on the $http response.  Stores the original version of the data
+                 * on the response as "originalData" and sets the deserialized data in the "data" property.
+                 * @param response The $http response object
+                 * @returns {*} The $http response
+                 */
+                RailsResource.deserialize = function (response) {
+                    response.data = this.config.serializer.deserialize(response.data, this.config.resourceConstructor);
+                    return response;
+                };
+
+                /**
+                 * Deprecated, see interceptors
+                 * Transform data after response has been converted to a resource instance
+                 * @deprecated
+                 * @param promise
+                 * @param context
+                 */
+                RailsResource.callResponseInterceptors = function (promise, context) {
+                    var config = this.config;
+                    forEachDependency(config.responseInterceptors, function (interceptor) {
+                        promise.resource = config.resourceConstructor;
+                        promise.context = context;
+                        promise = interceptor(promise);
+                    });
+                    return promise;
+                };
+
+                /**
+                 * Deprecated, see interceptors
+                 * Transform data after response has been converted to a resource instance
+                 * @deprecated
+                 * @param promise
+                 * @param context
+                 */
+                RailsResource.callAfterResponseInterceptors = function (promise) {
+                    var config = this.config;
+                    // data is now deserialized. call response interceptors including afterResponse
+                    forEachDependency(config.afterResponseInterceptors, function (interceptor) {
+                        promise.resource = config.resourceConstructor;
+                        promise = interceptor(promise);
+                    });
+
+                    return promise;
+                };
+
+                RailsResource.runInterceptorPhase = function (phase, context, promise) {
+                    promise = promise || $q.resolve(context);
+                    var config = this.config, chain = [];
+
+                    forEachDependency(config.interceptors, function (interceptor) {
+                        if (interceptor[phase] || interceptor[phase + 'Error']) {
+                            chain.push(interceptor[phase], interceptor[phase + 'Error']);
+                        }
+                    });
+
+                    while (chain.length) {
+                        var thenFn = chain.shift();
+                        var rejectFn = chain.shift();
+
+                        promise = promise.then(createInterceptorSuccessCallback(thenFn, config.resourceConstructor, context),
+                            createInterceptorRejectionCallback(rejectFn, config.resourceConstructor, context));
+                    }
+
+                    return promise;
+                };
+
+                /**
+                 * Executes an HTTP request using $http.
+                 *
+                 * This method is used by all RailsResource operations that execute HTTP requests.  Handles serializing
+                 * the request data using the resource serializer, root wrapping (if enabled), deserializing the response
+                 * data using the resource serializer, root unwrapping (if enabled), and copying the result back into the
+                 * resource context if applicable.  Executes interceptors at each phase of the request / response to allow
+                 * users to build synchronous & asynchronous customizations to manipulate the data as necessary.
+                 *
+                 * @param httpConfig The config to pass to $http, see $http docs for details
+                 * @param context An optional reference to the resource instance that is the context for the operation.
+                 *      If specified, the result data will be copied into the context during the response handling.
+                 * @param resourceConfigOverrides An optional set of RailsResource configuration options overrides.
+                 *      These overrides allow users to build custom operations more easily with different resource settings.
+                 * @returns {Promise} The promise that will eventually be resolved after all request / response handling
+                 *      has completed.
+                 */
+                RailsResource.$http = function (httpConfig, context, resourceConfigOverrides) {
+                    var timeoutPromise, promise,
+                        config = angular.extend(angular.copy(this.config), resourceConfigOverrides || {}),
+                        resourceConstructor = config.resourceConstructor,
+                        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) {
+
+                        promise = this.runInterceptorPhase('beforeRequest', context, promise).then(function (httpConfig) {
+                            httpConfig = resourceConstructor.serialize(httpConfig);
+
+                            forEachDependency(config.requestTransformers, function (transformer) {
+                                httpConfig.data = transformer(httpConfig.data, config.resourceConstructor);
+                            });
+
+                            return httpConfig;
+                        });
+
+                        promise = this.runInterceptorPhase('beforeRequestWrapping', context, promise);
+
+                        if (config.rootWrapping) {
+                            promise = promise.then(function (httpConfig) {
+                                httpConfig.data = railsRootWrapper.wrap(httpConfig.data, config.resourceConstructor);
+                                return httpConfig;
+                            });
+                        }
+
+                        promise = this.runInterceptorPhase('request', context, promise).then(function (httpConfig) {
+                            return $http(httpConfig);
+                        });
+
+                    } 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) {
+                      // store off the data so we don't lose access to it after deserializing and unwrapping
+                      response.originalData = response.data;
+                      return response;
+                    });
+
+                    if (config.rootWrapping) {
+                        promise = promise.then(function (response) {
+                            return railsRootWrapper.unwrap(response, config.resourceConstructor, false);
+                        });
+                    }
+
+                    promise = this.runInterceptorPhase('beforeResponseDeserialize', context, promise).then(function (response) {
+                        return resourceConstructor.deserialize(response);
+                    });
+
+                    promise = this.callResponseInterceptors(promise, context);
+                    promise = this.runInterceptorPhase('response', context, promise).then(function (response) {
+                        if (context) {
+                            // we may not have response data
+                            if (response.hasOwnProperty('data') && angular.isObject(response.data)) {
+                                angular.extend(context, response.data);
+                            }
+                        }
+
+                        return config.fullResponse ? response : (context || response.data);
+                    });
+
+                    promise = this.callAfterResponseInterceptors(promise, context);
+                    promise = this.runInterceptorPhase('afterResponse', context, promise);
+                    promise = this.runInterceptorPhase('afterDeserialize', context, promise);
+                    return extendPromise(promise, {
+                        resource: config.resourceConstructor,
+                        context: context,
+                        abort: abortRequest
+                    });
+                };
+
+                /**
+                 * Processes query parameters before request.  You can override to modify
+                 * the query params or return a new object.
+                 *
+                 * @param {Object} queryParams - The query parameters for the request
+                 * @returns {Object} The query parameters for the request
+                 */
+                RailsResource.processParameters = function (queryParams) {
+                    var newParams = {};
+
+                    if (angular.isObject(queryParams) && this.config.underscoreParams) {
+                        angular.forEach(queryParams, function (v, k) {
+                            newParams[this.config.serializer.underscore(k)] = v;
+                        }, this);
+
+                        return newParams;
+                    }
+
+                    return queryParams;
+                };
+
+                RailsResource.getParameters = function (queryParams) {
+                    var params;
+
+                    if (this.config.defaultParams) {
+                        // we need to clone it so we don't modify it when we add the additional
+                        // query params below
+                        params = angular.copy(this.config.defaultParams);
+                    }
+
+                    if (angular.isObject(queryParams)) {
+                        params = angular.extend(params || {}, queryParams);
+                    }
+
+                    return this.processParameters(params);
+                };
+
+                RailsResource.getHttpConfig = function (queryParams) {
+                    var params = this.getParameters(queryParams);
+
+                    if (params) {
+                        return angular.extend({params: params}, this.config.httpConfig);
+                    }
+
+                    return angular.copy(this.config.httpConfig);
+                };
+
+                /**
+                 * Returns a URL from the given parameters.  You can override this method on your resource definitions to provide
+                 * custom logic for building your URLs or you can utilize the parameterized url strings to substitute values in the
+                 * URL string.
+                 *
+                 * The parameters in the URL string follow the normal Angular binding expression using {{ and }} for the start/end symbols.
+                 *
+                 * If the context is a number and the URL string does not contain an id parameter then the number is appended
+                 * to the URL string.
+                 *
+                 * 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 (ctxt, path) {
+                     var context = ctxt;
+                     if (!angular.isObject(ctxt)) {
+                         context = {};
+                         context[this.config.idAttribute] = ctxt;
+                     }
+
+                     return appendPath(this.buildUrl(context || {}), path);
+                 };
+
+                RailsResource.$get = function (url, queryParams) {
+                    return this.$http(angular.extend({method: 'get', url: url}, this.getHttpConfig(queryParams)));
+                };
+
+                RailsResource.query = function (queryParams, context) {
+                    return this.$get(this.resourceUrl(context), queryParams);
+                };
+
+                RailsResource.get = function (context, queryParams) {
+                    return this.$get(this.resourceUrl(context), queryParams);
+                };
+
+                /**
+                 * 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(this.constructor.resourceUrl(this), path);
+                };
+
+                /**
+                 * Executes $http with the resource instance as the context.
+                 *
+                 * @param httpConfig The config to pass to $http, see $http docs for details
+                 * @param context An optional reference to the resource instance that is the context for the operation.
+                 *      If specified, the result data will be copied into the context during the response handling.
+                 * @param resourceConfigOverrides An optional set of RailsResource configuration options overrides.
+                 *      These overrides allow users to build custom operations more easily with different resource settings.
+                 * @returns {Promise} The promise that will eventually be resolved after all request / response handling
+                 *      has completed.
+                 */
+                RailsResource.prototype.$http = function (httpConfig, resourceConfigOverrides) {
+                    return this.constructor.$http(httpConfig, this, resourceConfigOverrides);
+                };
+
+                angular.forEach(['post', 'put', 'patch'], function (method) {
+                    RailsResource['$' + method] = function (url, data, resourceConfigOverrides, queryParams) {
+                        // clone so we can manipulate w/o modifying the actual instance
+                        data = angular.copy(data);
+                        return this.$http(angular.extend({method: method, url: url, data: data}, this.getHttpConfig(queryParams)), null, resourceConfigOverrides);
+                    };
+
+                    RailsResource.prototype['$' + method] = function (url, context, queryParams) {
+                        // clone so we can manipulate w/o modifying the actual instance
+                        var data = angular.copy(this, {});
+                        return this.constructor.$http(angular.extend({method: method, url: url, data: data}, this.constructor.getHttpConfig(queryParams)), this);
+                    };
+                });
+
+                RailsResource.prototype.create = function () {
+                    return this.$post(this.$url(), this);
+                };
+
+                RailsResource.prototype.update = function () {
+                    return this['$' + this.constructor.config.updateMethod](this.$url(), this);
+                };
+
+                RailsResource.prototype.get = function () {
+                    return this.constructor.$http(angular.extend({method: 'GET', url: this.$url()}, this.constructor.getHttpConfig()), this);
+                };
+
+                RailsResource.prototype.isNew = function () {
+                    var idAttribute = this.constructor.config.idAttribute;
+                    return angular.isUndefined(this[idAttribute]) ||
+                        this[idAttribute] === null;
+                };
+
+                RailsResource.prototype.save = function () {
+                    if (this.isNew()) {
+                        return this.create();
+                    } else {
+                        return this.update();
+                    }
+                };
+
+                RailsResource.$delete = function (url, queryParams) {
+                    return this.$http(angular.extend({method: 'delete', url: url}, this.getHttpConfig(queryParams)));
+                };
+
+                RailsResource.prototype.$delete = function (url, queryParams) {
+                    return this.constructor.$http(angular.extend({method: 'delete', url: url}, this.constructor.getHttpConfig(queryParams)), this);
+                };
+
+                //using ['delete'] instead of .delete for IE7/8 compatibility
+                RailsResource.prototype.remove = RailsResource.prototype['delete'] = function () {
+                    return this.$delete(this.$url());
+                };
+
+                return RailsResource;
+
+                function appendPath(url, path) {
+                    if (path) {
+                        if (path[0] !== '/') {
+                            url += '/';
+                        }
+
+                        url += path;
+                    }
+
+                    return url;
+                }
+
+                function forEachDependency(list, callback) {
+                    var dependency;
+
+                    for (var i = 0, len = list.length; i < len; i++) {
+                        dependency = list[i];
+
+                        if (angular.isString(dependency)) {
+                            dependency = list[i] = RailsResourceInjector.getDependency(dependency);
+                        }
+
+                        callback(dependency);
+                    }
+                }
+
+                function addMixin(Resource, destination, mixin, callback) {
+                    var excludedKeys = ['included', 'extended,', 'configure'];
+
+                    if (!Resource.$mixins) {
+                        Resource.$mixins = [];
+                    }
+
+                    if (angular.isString(mixin)) {
+                        mixin = RailsResourceInjector.getDependency(mixin);
+                    }
+
+                    if (mixin && Resource.$mixins.indexOf(mixin) === -1) {
+                        angular.forEach(mixin, function (value, key) {
+                            if (excludedKeys.indexOf(key) === -1) {
+                                destination[key] = value;
+                            }
+                        });
+
+                        Resource.$mixins.push(mixin);
+
+                        if (angular.isFunction(callback)) {
+                            callback(Resource, mixin);
+                        }
+                    }
+                }
+
+                function loadExtensions(extensions) {
+                    var modules = [];
+
+                    angular.forEach(extensions, function (extensionName) {
+                        extensionName = 'RailsResource' + extensionName.charAt(0).toUpperCase() + extensionName.slice(1) + 'Mixin';
+
+                        modules.push(RailsResourceInjector.getDependency(extensionName));
+                    });
+
+                    return modules;
+                }
+
+                function booleanParam(value, defaultValue) {
+                    return angular.isUndefined(value) ? defaultValue : value;
+                }
+
+                function createInterceptorSuccessCallback(thenFn, resourceConstructor, context) {
+                    return function (data) {
+                        return (thenFn || angular.identity)(data, resourceConstructor, context);
+                    };
+                }
+
+                function createInterceptorRejectionCallback(rejectFn, resourceConstructor, context) {
+                    return function (rejection) {
+                        // can't use identity because we need to return a rejected promise to keep the error chain going
+                        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;
+                }
+            }];
+    });
+
+    angular.module('rails').factory('railsResourceFactory', ['RailsResource', function (RailsResource) {
+        return function (config) {
+            function Resource() {
+                Resource.__super__.constructor.apply(this, arguments);
+            }
+
+            RailsResource.extendTo(Resource);
+            Resource.configure(config);
+
+            return Resource;
+        };
+    }]);
+
+}());