angularjs-rails-resource 0.2.1 → 0.2.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjM2MTM3OTRmYjQzZDE1ZGNhZjk1YTM2MDk4ZmUxNTJjMzBmYzBmOA==
+    ZGU4OWY0N2I0MGNjN2U0OGQ1OGZmZWE2ODgwYTlhZWIwZGMxOTdjZg==
   data.tar.gz: !binary |-
-    NjAyYWZmZGEwNzQ2MjhmODk1OWIyMTRiMWY1NDBmOWQxN2VkMGQ3Ng==
+    NmNkNDkxOWRhMzJkNGU0MTVhODFmN2FlZmI1ZmM4NzgxM2NhYmM3Zg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MWU4ZDAzMjZhMGM5NTIyZmZlMzY4YjQ3M2I3MzJmMmI1MDI4ZWI2ZjE5NmZh
-    Njc5NzU0YzNkNjFlYjI2OGM1NzJlNDczOTQxOGU4ZDgwNDgzYzVjZjE2Yzgy
-    ODQyYWI4NTM3NGYyMWY0MDlmNjkyM2M0ZGQyOWY0NTEwM2E2Njc=
+    OGJiNjBiOGYzMjczNTcyZmE2NGZjZDQ5NjJjYjI0Nzk3MTA5YmNiOTk5OGU0
+    YmNjYTMzY2RjNzExNzA2YjlmMmYwNGQ3YzgyZmVhYjBkMGEwZGJiOTIwOGE0
+    NmY1MzY0MGMyOWZkYTIwNDQyY2RiNmY3NmY1YjBlYzZmNTkzN2Y=
   data.tar.gz: !binary |-
-    ODkyMTcyNmZhYjVjYmNlZWM3NTAzNjY4ZDYzYmU0Yjk3NGQxYjQyNzAxMWQy
-    ODE5NjQ4YmNiMmNhOTRjZGQyOGZjNjZkOTUyYzg3NWI5MmRiYjQ5ZDZjM2Fk
-    MGY5ZDM2YzZiNGZiZDNlYTdhMjA4M2UyNTZhMTYyMmQ4ODEwM2Q=
+    Yzg0YjlhMjJlZDc3ZTdjMmY0NWQxZWUyZTBhMGFmODM5M2Q0ZmRjY2VhNjlk
+    ZWEwNWNlN2M3ZWQzOTg4NTQwN2EzZmEzMzc1YWUxY2I1ZGQ4YTQxYjg2ZjE1
+    MTMzNDk3MmRhNmRjZTg2MTllNjhhYTg5YjAyMDM4MGFlMjlmOTE=

data/README.md

@@ -132,6 +132,7 @@ The following options are available for the config object passed to the factory
          * **Accept** - application/json
          * **Content-Type** - application/json
  * **defaultParams** *(optional)* - If the resource expects a default set of query params on every call you can specify them here.
+ * **updateMethod** *(optional)* - Allows overriding the default HTTP method (PUT) used for update.  Valid values are "post", "put", or "patch".
  * **requestTransformers** *(optional) - See [Transformers / Interceptors](#transformers--interceptors)
  * **responseInterceptors** *(optional)* - See [Transformers / Interceptors](#transformers--interceptors)
  * **afterResponseInterceptors** *(optional)* - See [Transformers / Interceptors](#transformers--interceptors)
@@ -139,6 +140,24 @@ The following options are available for the config object passed to the factory
 **NOTE:** The names should be specified using camel case when using the key transformations because that happens before the root wrapping by default.
 For example, you should specify "publishingCompany" and "publishingCompanies" instead of "publishing_company" and "publishing_companies".
 
+### Provider Configuration
+<code>railsResourceFactory</code> can be injected as <code>railsResourceFactoryProvider</code> into your app's config method to configure defaults for all the resources application-wide.
+The individual resource configuration takes precedence over application-wide default configuration values.
+Each configuration option listed is exposed as a method on the provider that takes the configuration value as the parameter and returns the provider to allow method chaining.
+
+* enableRootWrapping - {function(boolean):railsSerializerProvider}
+* httpConfig - {function(object):railsSerializerProvider}
+* defaultParams - {function(object):railsSerializerProvider}
+* updateMethod - {function(boolean):railsSerializerProvider}
+
+For example, to turn off the root wrapping application-wide and set the update method to PATCH:
+
+````javascript
+app.config(function (railsResourceFactoryProvider) {
+    railsResourceFactoryProvider.enableRootWrapping(false).updateMethod('patch');
+);
+````
+
 ## Resource URLs
 The URL can be specified as one of three ways:
 
@@ -259,8 +278,8 @@ AngularJS automatically excludes all attribute keys that begin with $ in their t
     * **returns** {Serializer} - A Serializer constructor function
 
 ### Configuration
-The <code>railsSerializer</code> function takes a customizer function that is called on create within the context of the constructed Serializer.  From within the customizer function you can call customization functions that affect what gets serialized and how or override the default options.
-In addition, <code>railsSerializer</code> exposes a field <code>defaultOptions</code> that allows you to globally override the defaults for the configuration options.
+The <code>railsSerializer</code> function takes a customizer function that is called on create within the context of the constructed Serializer.
+From within the customizer function you can call customization functions that affect what gets serialized and how or override the default options.
 
 #### Configuration Options
 Serializers have the following available configuration options:
@@ -279,13 +298,29 @@ Serializers have the following available configuration options:
     * parameters
         * **attribute** {string} - The name as it appeared in the JSON
     * **returns** {string} - The name as it should appear in the resource
-* excludeByDefault {boolean} - Specifies whether or not JSON serialization should exclude all attributes from serialization by default.
-    * default: false
 * exclusionMatchers {array} - An list of rules that should be applied to determine whether or not an attribute should be excluded.  The values in the array can be one of the following types:
     * 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.
 
+#### Provider Configuration
+<code>railsSerializer</code> can be injected as <code>railsSerializerProvider</code> into your app's config method to configure defaults for all the serializers application-wide.
+Each configuration option listed is exposed as a method on the provider that takes the configuration value as the parameter and returns the provider to allow method chaining.
+
+* underscore - {function(fn):railsSerializerProvider}
+* camelize - {function(fn):railsSerializerProvider}
+* pluralize - {function(fn):railsSerializerProvider}
+* exclusionMatchers - {function(matchers):railsSerializerProvider}
+
+For example, to turn off the key renaming from underscore to camel case and vice versa you would do:
+
+````javascript
+app.config(function (railsSerializerProvider) {
+    railsSerializerProvider.underscore(function (value) { return value; })
+        .camelize(function (value) { return value; });
+);
+````
+
 #### Customization API
 The customizer function passed to the railsSerializer has available to it the following methods for altering the serialization of an object.  None of these methods support nested attribute names (e.g. <code>'books.publicationDate'</code>), in order to customize the serialization of the <code>books</code> objects you would need to specify a custom serializer for the <code>books</code> attribute.
 

data/angularjs-rails-resource.gemspec

@@ -5,8 +5,9 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Tommy Odom", "Chris Chase"]
   gem.email         = ["odom@finelineprototyping.com", "chris@finelineprototyping.com"]
   gem.description   = %q{A small AngularJS add-on for integrating with Rails via JSON more easily.}
-  gem.summary       = %q{}
+  gem.summary       = %q{AngularJS add-on resource add-on for integrating with Rails}
   gem.homepage      = "https://github.com/finelineprototyping/angularjs-rails-resource"
+  gem.license       = 'MIT'
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/lib/angularjs-rails-resource/version.rb

@@ -1,7 +1,7 @@
 module Angularjs
   module Rails
     module Resource
-      VERSION = '0.2.1'
+      VERSION = '0.2.2'
     end
   end
 end

data/test/unit/angularjs/rails/resourceProviderSpec.js

@@ -0,0 +1,43 @@
+describe('resource provider factory config', function () {
+    'use strict';
+
+    it('should allow disabling root wrapping globally', function () {
+        module('rails', function (railsResourceFactoryProvider) {
+            expect(railsResourceFactoryProvider.enableRootWrapping(false)).toBe(railsResourceFactoryProvider);
+        });
+
+        inject(function (railsResourceFactory) {
+            expect(railsResourceFactory({name: 'test', url: '/test'}).enableRootWrapping).toBe(false);
+        });
+    });
+
+    it('should allow setting updateMethod globally', function () {
+        module('rails', function (railsResourceFactoryProvider) {
+            expect(railsResourceFactoryProvider.updateMethod('patch')).toBe(railsResourceFactoryProvider);
+        });
+
+        inject(function (railsResourceFactory) {
+            expect(railsResourceFactory({name: 'test', url: '/test'}).updateMethod).toBe('patch');
+        });
+    });
+
+    it('should allow setting http headers options globally', function () {
+        module('rails', function (railsResourceFactoryProvider) {
+            expect(railsResourceFactoryProvider.httpConfig({headers: {'test': "header"}})).toBe(railsResourceFactoryProvider);
+        });
+
+        inject(function (railsResourceFactory) {
+            expect(railsResourceFactory({name: 'test', url: '/test'}).httpConfig.headers).toEqualData({'Accept': 'application/json', 'Content-Type': 'application/json', 'test': 'header'});
+        });
+    });
+
+    it('should allow setting default query parameters options globally', function () {
+        module('rails', function (railsResourceFactoryProvider) {
+            expect(railsResourceFactoryProvider.defaultParams({'test': "1"})).toBe(railsResourceFactoryProvider);
+        });
+
+        inject(function (railsResourceFactory) {
+            expect(railsResourceFactory({name: 'test', url: '/test'}).defaultParams).toEqualData({'test': '1'});
+        });
+    });
+});

data/test/unit/angularjs/rails/resourceSpec.js

@@ -228,6 +228,53 @@ describe('railsResourceFactory', function () {
             expect(data).toEqualData({id: 123, abcDef: 'xyz', xyz: 'abc', extra: 'test'});
         }));
 
+        it('should be able to create new instance and update it using PATCH', inject(function($httpBackend) {
+            var promise, Resource, data, defaultParamsConfig = {};
+
+            angular.copy(config, defaultParamsConfig);
+            defaultParamsConfig.updateMethod = 'patch';
+
+            Resource = factory(defaultParamsConfig);
+            data = new Resource({abcDef: 'xyz'});
+
+            $httpBackend.expectPOST('/test', {test: {abc_def: 'xyz'}}).respond(200, {test: {id: 123, abc_def: 'xyz'}});
+            data.create();
+            $httpBackend.flush(1);
+
+            expect(data).toEqualData({id: 123, abcDef: 'xyz'});
+
+            $httpBackend.expectPATCH('/test/123', {test: {abc_def: 'xyz', id: 123, xyz: 'abc'}}).respond(200, {test: {id: 123, abc_def: 'xyz', xyz: 'abc', extra: 'test'}});
+            data.xyz = 'abc';
+            data.update();
+            $httpBackend.flush();
+
+            expect(data).toEqualData({id: 123, abcDef: 'xyz', xyz: 'abc', extra: 'test'});
+        }));
+
+        it('should be able to create new instance and update it using save using PATCH', inject(function($httpBackend) {
+            var promise, Resource, data, defaultParamsConfig = {};
+
+            angular.copy(config, defaultParamsConfig);
+            defaultParamsConfig.updateMethod = 'patch';
+
+            Resource = factory(defaultParamsConfig);
+            data = new Resource({abcDef: 'xyz'});
+
+            $httpBackend.expectPOST('/test', {test: {abc_def: 'xyz'}}).respond(200, {test: {id: 123, abc_def: 'xyz'}});
+            data.save();
+            $httpBackend.flush(1);
+
+            expect(data).toEqualData({id: 123, abcDef: 'xyz'});
+
+            $httpBackend.expectPATCH('/test/123', {test: {abc_def: 'xyz', id: 123, xyz: 'abc'}}).respond(200, {test: {id: 123, abc_def: 'xyz', xyz: 'abc', extra: 'test'}});
+            data.xyz = 'abc';
+            data.save();
+            $httpBackend.flush();
+
+            expect(data).toEqualData({id: 123, abcDef: 'xyz', xyz: 'abc', extra: 'test'});
+        }));
+
+
         it('create with default params should add parameter abc=1', inject(function($httpBackend) {
             var promise, Resource, data, defaultParamsConfig = {};
 

data/test/unit/angularjs/rails/serializationSpec.js

@@ -1,333 +1,395 @@
-describe('railsUrlSerializer', function () {
+describe('railsSerializer', function () {
     'use strict';
-    var factory, railsInjector;
 
-    function createSerializer(options, customizer) {
-        return railsInjector.createService(factory(options, customizer));
-    }
-
-    beforeEach(module('rails'));
-
-    beforeEach(inject(function (railsSerializer, RailsResourceInjector) {
-        factory = railsSerializer;
-        railsInjector = RailsResourceInjector;
-    }));
-
-    it('should support customizer being first parameter', function () {
-        var called = false;
-
-        createSerializer(function () {
-            called = true;
+    describe('provider config', function () {
+        it('should allow overriding underscore method', function () {
+            var overrideCalled = false;
+
+            module('rails', function (railsSerializerProvider) {
+                expect(railsSerializerProvider.underscore(function (value) {
+                    overrideCalled = true;
+                    return value;
+                })).toBe(railsSerializerProvider);
+            });
+
+            inject(function (railsSerializer, RailsResourceInjector) {
+                var test = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'};
+                expect(RailsResourceInjector.createService(railsSerializer()).serialize(test)).toEqualData(test);
+                expect(overrideCalled).toBeTruthy();
+            });
         });
 
-        expect(called).toBeTruthy();
-    });
-
-    it('should support customizer with options as first parameter', function () {
-        var called = false;
-
-        createSerializer({}, function () {
-            called = true;
+        it('should allow overriding camelize method', function () {
+            var overrideCalled = false;
+
+            module('rails', function (railsSerializerProvider) {
+                expect(railsSerializerProvider.camelize(function (value) {
+                    overrideCalled = true;
+                    return value;
+                })).toBe(railsSerializerProvider);
+            });
+
+            inject(function (railsSerializer, RailsResourceInjector) {
+                var test = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'};
+                expect(RailsResourceInjector.createService(railsSerializer()).deserialize(test)).toEqualData(test);
+                expect(overrideCalled).toBeTruthy();
+            });
         });
 
-        expect(called).toBeTruthy();
+        it('should allow overriding pluralize method', function () {
+            module('rails', function (railsSerializerProvider) {
+                expect(railsSerializerProvider.pluralize(function (value) {
+                    return value + 'ies';
+                })).toBe(railsSerializerProvider);
+            });
 
-    });
-
-    describe('default config', function () {
-        var serializer;
-
-        beforeEach(function () {
-            serializer = createSerializer();
-        });
-
-        it('should underscore attributes on single object', function () {
-            var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'},
-                result = serializer.serialize(orig);
-            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
-            result = serializer.deserialize(result);
-            expect(result).toEqualData(orig);
+            inject(function (railsSerializer, RailsResourceInjector) {
+                expect(RailsResourceInjector.createService(railsSerializer()).pluralize('cook')).toEqual('cookies');
+            });
         });
 
-        it('should underscore attributes on nested objects', function () {
-            var orig = {id: 6, title: 'Winds of Winter', pages: 1105, publicationDate: '2020-05-25', author: {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'}},
-                result = serializer.serialize(orig);
-            expect(result).toEqualData({id: 6, title: 'Winds of Winter', pages: 1105, publication_date: '2020-05-25', author: {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'}});
-            result = serializer.deserialize(result);
-            expect(result).toEqualData(orig);
-        });
-
-        it('should underscore attribute inside array objects', function () {
-            var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', books: [
-                    {id: 1, title: 'A Game of Thrones', publicationDate: '1996-08-06'}
-                ]},
-                result = serializer.serialize(orig);
-            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', books: [
-                {id: 1, title: 'A Game of Thrones', publication_date: '1996-08-06'}
-            ]});
-            result = serializer.deserialize(result);
-            expect(result).toEqualData(orig);
-        });
+        it('should allow overriding exclusionMatchers method', function () {
+            module('rails', function (railsSerializerProvider) {
+                expect(railsSerializerProvider.exclusionMatchers(['_'])).toBe(railsSerializerProvider);
+            });
 
-        it('should support primitive arrays', function () {
-            var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', books: [1, 2, 3]},
-                result = serializer.serialize(orig);
-            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', books: [1, 2, 3]});
-            result = serializer.deserialize(result);
-            expect(result).toEqualData(orig);
+            inject(function (railsSerializer, RailsResourceInjector) {
+                var test = {id: 1, _firstName: 'George', _middleName: 'R. R.', lastName: 'Martin'};
+                expect(RailsResourceInjector.createService(railsSerializer()).serialize(test)).toEqualData({id: 1, last_name: 'Martin'});
+            });
         });
-
-        it('should exclude attributes that start with $', function () {
-            var result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
-            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
-            result = serializer.deserialize({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
-            expect(result).toEqualData({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
-        });
-
-        it('should exclude functions', function () {
-            var result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $books: [], getNumBooks: function () {
-                this.$books.length
-            }});
-            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
-        });
-
     });
 
-    describe('custom options', function () {
-        it('should allow overriding attribute transformation functions with undefined', function () {
-            var test,
-                serializer = createSerializer({underscore: undefined, camelize: undefined});
-
-            test = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'};
-            expect(serializer.serialize(test)).toEqualData(test);
-            test = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'};
-            expect(serializer.deserialize(test)).toEqualData(test);
-        });
+    describe('default provider options', function () {
+        var factory, railsInjector;
 
-        it('should allow overriding attribute transformation with custom function', function () {
-            var result,
-                serializer = createSerializer({
-                    underscore: function (attribute) {
-                        return 'x' + attribute
-                    },
-                    camelize: function (attribute) {
-                        return 'y' + attribute
-                    }
-                });
+        function createSerializer(options, customizer) {
+            return railsInjector.createService(factory(options, customizer));
+        }
 
-            result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
-            expect(result).toEqualData({xid: 1, xfirstName: 'George', xmiddleName: 'R. R.', xlastName: 'Martin'});
-            result = serializer.deserialize({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
-            expect(result).toEqualData({yid: 1, yfirst_name: 'George', ymiddle_name: 'R. R.', ylast_name: 'Martin'});
-        });
+        beforeEach(module('rails'));
 
-        it('should allow safely ignore null excludePrefixes', function () {
-            var result, underscored, camelized,
-                serializer = createSerializer({exclusionMatchers: null});
+        beforeEach(inject(function (railsSerializer, RailsResourceInjector) {
+            factory = railsSerializer;
+            railsInjector = RailsResourceInjector;
+        }));
 
-            camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
-            underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
-            result = serializer.serialize(camelized);
-            expect(result).toEqualData(underscored);
-            result = serializer.deserialize(underscored);
-            expect(result).toEqualData(camelized);
-        });
+        describe('default config', function () {
+            var serializer;
 
-        it('should allow safely ignore undefined excludePrefixes', function () {
-            var result, underscored, camelized,
-                serializer = createSerializer({exclusionMatchers: undefined});
+            beforeEach(function () {
+                serializer = createSerializer();
+            });
 
-            camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
-            underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
-            result = serializer.serialize(camelized);
-            expect(result).toEqualData(underscored);
-            result = serializer.deserialize(underscored);
-            expect(result).toEqualData(camelized);
-        });
+            it('should support customizer being first parameter', function () {
+                var called = false;
 
-        it('should allow empty excludePrefixes', function () {
-            var result, underscored, camelized,
-                serializer = createSerializer({exclusionMatchers: []});
+                createSerializer(function () {
+                    called = true;
+                });
 
-            camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
-            underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
-            result = serializer.serialize(camelized);
-            expect(result).toEqualData(underscored);
-            result = serializer.deserialize(underscored);
-            expect(result).toEqualData(camelized);
-        });
+                expect(called).toBeTruthy();
+            });
 
-        it('should treat exclusionMatcher strings as prefix exclusions', function () {
-            var result,
-                serializer = createSerializer({exclusionMatchers: ['x']});
+            it('should support customizer with options as first parameter', function () {
+                var called = false;
 
-            result = serializer.serialize({xid: 1, firstNamex: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
-            expect(result).toEqualData({first_namex: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
-            result = serializer.deserialize({xid: 1, first_namex: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
-            expect(result).toEqualData({xid: 1, firstNamex: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
-        });
+                createSerializer({}, function () {
+                    called = true;
+                });
 
-        it('should use combination of string prefix, function, and regexp for exclusions', function () {
-            var result,
-                serializer = createSerializer({exclusionMatchers: ['x', /^$/, function (key) {
-                    return key === 'middleName';
-                }]});
+                expect(called).toBeTruthy();
+
+            });
+
+            it('should underscore attributes on single object', function () {
+                var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'},
+                    result = serializer.serialize(orig);
+                expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+                result = serializer.deserialize(result);
+                expect(result).toEqualData(orig);
+            });
+
+            it('should underscore attributes on nested objects', function () {
+                var orig = {id: 6, title: 'Winds of Winter', pages: 1105, publicationDate: '2020-05-25', author: {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'}},
+                    result = serializer.serialize(orig);
+                expect(result).toEqualData({id: 6, title: 'Winds of Winter', pages: 1105, publication_date: '2020-05-25', author: {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'}});
+                result = serializer.deserialize(result);
+                expect(result).toEqualData(orig);
+            });
+
+            it('should underscore attribute inside array objects', function () {
+                var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', books: [
+                        {id: 1, title: 'A Game of Thrones', publicationDate: '1996-08-06'}
+                    ]},
+                    result = serializer.serialize(orig);
+                expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', books: [
+                    {id: 1, title: 'A Game of Thrones', publication_date: '1996-08-06'}
+                ]});
+                result = serializer.deserialize(result);
+                expect(result).toEqualData(orig);
+            });
+
+            it('should support primitive arrays', function () {
+                var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', books: [1, 2, 3]},
+                    result = serializer.serialize(orig);
+                expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', books: [1, 2, 3]});
+                result = serializer.deserialize(result);
+                expect(result).toEqualData(orig);
+            });
+
+            it('should exclude attributes that start with $', function () {
+                var result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
+                expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+                result = serializer.deserialize({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
+                expect(result).toEqualData({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
+            });
+
+            it('should exclude functions', function () {
+                var result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $books: [], getNumBooks: function () {
+                    this.$books.length
+                }});
+                expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+            });
 
-            result = serializer.serialize({xid: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
-            expect(result).toEqualData({first_name: 'George', last_name: 'Martin'});
-            result = serializer.deserialize({xid: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
-            expect(result).toEqualData({xid: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birth_date: '1948-09-20'});
         });
-    });
 
-    describe('customized serialization', function () {
-        var camelizedAuthor = {
-                id: 1,
-                firstName: 'George',
-                middleName: 'R. R.',
-                lastName: 'Martin',
-                birthDate: '1948-09-20',
-                books: [
-                    {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publicationDate: '1996-08-06', authorId: 1},
-                    {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publicationDate: '1999-03-01', authorId: 1},
-                ]
-            },
-            underscoredAuthor = {
-                id: 1,
-                first_name: 'George',
-                middle_name: 'R. R.',
-                last_name: 'Martin',
-                birth_date: '1948-09-20',
-                books: [
-                    {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publication_date: '1996-08-06', author_id: 1},
-                    {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publication_date: '1999-03-01', author_id: 1},
-                ]
-            };
-
-        it('should allow single exclusion', function () {
-            var result,
-                serializer = createSerializer(function (config) {
-                    config.exclude('books');
-                });
+        describe('custom options', function () {
+            it('should allow overriding attribute transformation functions with undefined', function () {
+                var test,
+                    serializer = createSerializer({underscore: undefined, camelize: undefined});
+
+                test = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'};
+                expect(serializer.serialize(test)).toEqualData(test);
+                test = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'};
+                expect(serializer.deserialize(test)).toEqualData(test);
+            });
+
+            it('should allow overriding attribute transformation with custom function', function () {
+                var result,
+                    serializer = createSerializer({
+                        underscore: function (attribute) {
+                            return 'x' + attribute
+                        },
+                        camelize: function (attribute) {
+                            return 'y' + attribute
+                        }
+                    });
 
-            result = serializer.serialize(camelizedAuthor);
-            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', birth_date: '1948-09-20'});
-            result = serializer.deserialize(underscoredAuthor);
-            expect(result).toEqualData(camelizedAuthor);
+                result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
+                expect(result).toEqualData({xid: 1, xfirstName: 'George', xmiddleName: 'R. R.', xlastName: 'Martin'});
+                result = serializer.deserialize({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+                expect(result).toEqualData({yid: 1, yfirst_name: 'George', ymiddle_name: 'R. R.', ylast_name: 'Martin'});
+            });
+
+            it('should allow safely ignore null excludePrefixes', function () {
+                var result, underscored, camelized,
+                    serializer = createSerializer({exclusionMatchers: null});
+
+                camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
+                underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
+                result = serializer.serialize(camelized);
+                expect(result).toEqualData(underscored);
+                result = serializer.deserialize(underscored);
+                expect(result).toEqualData(camelized);
+            });
+
+            it('should allow safely ignore undefined excludePrefixes', function () {
+                var result, underscored, camelized,
+                    serializer = createSerializer({exclusionMatchers: undefined});
+
+                camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
+                underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
+                result = serializer.serialize(camelized);
+                expect(result).toEqualData(underscored);
+                result = serializer.deserialize(underscored);
+                expect(result).toEqualData(camelized);
+            });
+
+            it('should allow empty excludePrefixes', function () {
+                var result, underscored, camelized,
+                    serializer = createSerializer({exclusionMatchers: []});
+
+                camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
+                underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
+                result = serializer.serialize(camelized);
+                expect(result).toEqualData(underscored);
+                result = serializer.deserialize(underscored);
+                expect(result).toEqualData(camelized);
+            });
+
+            it('should treat exclusionMatcher strings as prefix exclusions', function () {
+                var result,
+                    serializer = createSerializer({exclusionMatchers: ['x']});
+
+                result = serializer.serialize({xid: 1, firstNamex: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
+                expect(result).toEqualData({first_namex: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
+                result = serializer.deserialize({xid: 1, first_namex: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
+                expect(result).toEqualData({xid: 1, firstNamex: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
+            });
+
+            it('should use combination of string prefix, function, and regexp for exclusions', function () {
+                var result,
+                    serializer = createSerializer({exclusionMatchers: ['x', /^$/, function (key) {
+                        return key === 'middleName';
+                    }]});
+
+                result = serializer.serialize({xid: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
+                expect(result).toEqualData({first_name: 'George', last_name: 'Martin'});
+                result = serializer.deserialize({xid: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
+                expect(result).toEqualData({xid: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birth_date: '1948-09-20'});
+            });
         });
 
-        it('should allow variable exclusions', function () {
-            var result,
-                serializer = createSerializer(function (config) {
-                    config.exclude('books', 'birthDate');
-                });
+        describe('customized serialization', function () {
+            var camelizedAuthor = {
+                    id: 1,
+                    firstName: 'George',
+                    middleName: 'R. R.',
+                    lastName: 'Martin',
+                    birthDate: '1948-09-20',
+                    books: [
+                        {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publicationDate: '1996-08-06', authorId: 1},
+                        {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publicationDate: '1999-03-01', authorId: 1},
+                    ]
+                },
+                underscoredAuthor = {
+                    id: 1,
+                    first_name: 'George',
+                    middle_name: 'R. R.',
+                    last_name: 'Martin',
+                    birth_date: '1948-09-20',
+                    books: [
+                        {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publication_date: '1996-08-06', author_id: 1},
+                        {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publication_date: '1999-03-01', author_id: 1},
+                    ]
+                };
+
+            it('should allow single exclusion', function () {
+                var result,
+                    serializer = createSerializer(function (config) {
+                        config.exclude('books');
+                    });
 
-            result = serializer.serialize(camelizedAuthor);
-            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
-            result = serializer.deserialize(underscoredAuthor);
-            expect(result).toEqualData(camelizedAuthor);
-        });
+                result = serializer.serialize(camelizedAuthor);
+                expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', birth_date: '1948-09-20'});
+                result = serializer.deserialize(underscoredAuthor);
+                expect(result).toEqualData(camelizedAuthor);
+            });
 
-        it('should allow renaming attributes', function () {
-            var result,
-                serializer = createSerializer(function (config) {
-                    // this & config should be interchangeable
-                    this.exclude('books', 'birthDate');
-                    this.rename('id', 'authorId');
-                    this.rename('firstName', 'first');
-                    this.rename('middleName', 'middle');
-                    config.rename('lastName', 'last');
-                });
+            it('should allow variable exclusions', function () {
+                var result,
+                    serializer = createSerializer(function (config) {
+                        config.exclude('books', 'birthDate');
+                    });
 
-            result = serializer.serialize(camelizedAuthor);
-            expect(result).toEqualData({author_id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
-            result = serializer.deserialize({author_id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
-            expect(result).toEqualData({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
-        });
+                result = serializer.serialize(camelizedAuthor);
+                expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+                result = serializer.deserialize(underscoredAuthor);
+                expect(result).toEqualData(camelizedAuthor);
+            });
+
+            it('should allow renaming attributes', function () {
+                var result,
+                    serializer = createSerializer(function (config) {
+                        // this & config should be interchangeable
+                        this.exclude('books', 'birthDate');
+                        this.rename('id', 'authorId');
+                        this.rename('firstName', 'first');
+                        this.rename('middleName', 'middle');
+                        config.rename('lastName', 'last');
+                    });
 
-        it('should allow nested attributes', function () {
-            var result,
-                serializer = createSerializer(function () {
-                    this.nestedAttribute('books')
-                });
+                result = serializer.serialize(camelizedAuthor);
+                expect(result).toEqualData({author_id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+                result = serializer.deserialize({author_id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+                expect(result).toEqualData({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
+            });
 
-            result = serializer.serialize(camelizedAuthor);
-            expect(result['books_attributes']).toEqualData([
-                {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publication_date: '1996-08-06', author_id: 1},
-                {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publication_date: '1999-03-01', author_id: 1}
-            ]);
-            result = serializer.deserialize(underscoredAuthor);
-            expect(result).toEqualData(camelizedAuthor);
-        });
+            it('should allow nested attributes', function () {
+                var result,
+                    serializer = createSerializer(function () {
+                        this.nestedAttribute('books')
+                    });
 
-        it('should add custom attribute from function', function () {
-            var result,
-                serializer = createSerializer(function () {
-                    this.add('numBooks', function (author) {
-                        return author.books.length;
+                result = serializer.serialize(camelizedAuthor);
+                expect(result['books_attributes']).toEqualData([
+                    {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publication_date: '1996-08-06', author_id: 1},
+                    {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publication_date: '1999-03-01', author_id: 1}
+                ]);
+                result = serializer.deserialize(underscoredAuthor);
+                expect(result).toEqualData(camelizedAuthor);
+            });
+
+            it('should add custom attribute from function', function () {
+                var result,
+                    serializer = createSerializer(function () {
+                        this.add('numBooks', function (author) {
+                            return author.books.length;
+                        });
                     });
-                });
 
-            result = serializer.serialize(camelizedAuthor);
-            expect(result['num_books']).toBe(2);
-        });
+                result = serializer.serialize(camelizedAuthor);
+                expect(result['num_books']).toBe(2);
+            });
 
-        it('should add custom attribute from constant value', function () {
-            var result,
-                serializer = createSerializer(function () {
-                    this.add('numBooks', 2);
-                });
+            it('should add custom attribute from constant value', function () {
+                var result,
+                    serializer = createSerializer(function () {
+                        this.add('numBooks', 2);
+                    });
 
-            result = serializer.serialize(camelizedAuthor);
-            expect(result['num_books']).toBe(2);
-        });
+                result = serializer.serialize(camelizedAuthor);
+                expect(result['num_books']).toBe(2);
+            });
 
-        it('should use custom serializer for books', function () {
-            var result, serializedBooks, underscored,
-                serializer = createSerializer(function () {
-                    this.serializeWith('books', factory(function () {
-                        this.rename('publicationDate', 'published');
-                    }));
-                });
+            it('should use custom serializer for books', function () {
+                var result, serializedBooks, underscored,
+                    serializer = createSerializer(function () {
+                        this.serializeWith('books', factory(function () {
+                            this.rename('publicationDate', 'published');
+                        }));
+                    });
 
-            result = serializer.serialize(camelizedAuthor);
-            serializedBooks = [
-                {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', published: '1996-08-06', author_id: 1},
-                {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', published: '1999-03-01', author_id: 1}
-            ];
-
-            expect(result['books']).toEqualData(serializedBooks);
-            underscored = angular.copy(underscoredAuthor);
-            underscored['books'] = serializedBooks;
-            result = serializer.deserialize(underscored);
-            expect(result).toEqualData(camelizedAuthor);
+                result = serializer.serialize(camelizedAuthor);
+                serializedBooks = [
+                    {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', published: '1996-08-06', author_id: 1},
+                    {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', published: '1999-03-01', author_id: 1}
+                ];
+
+                expect(result['books']).toEqualData(serializedBooks);
+                underscored = angular.copy(underscoredAuthor);
+                underscored['books'] = serializedBooks;
+                result = serializer.deserialize(underscored);
+                expect(result).toEqualData(camelizedAuthor);
+            });
         });
-    });
 
-    describe('default exclusion serialization', function () {
-        it('should only serialize id', function () {
-            var result,
-                serializer = createSerializer(function (config) {
-                    // this & config should be interchangeable
-                    this.only('id');
-                });
+        describe('default exclusion serialization', function () {
+            it('should only serialize id', function () {
+                var result,
+                    serializer = createSerializer(function (config) {
+                        // this & config should be interchangeable
+                        this.only('id');
+                    });
 
-            result = serializer.serialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
-            expect(result).toEqualData({id: 1});
-            result = serializer.deserialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
-            expect(result).toEqualData({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
-        });
+                result = serializer.serialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+                expect(result).toEqualData({id: 1});
+                result = serializer.deserialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+                expect(result).toEqualData({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+            });
 
-        it('should only serialize id and last', function () {
-            var result,
-                serializer = createSerializer(function (config) {
-                    this.only('id', 'last');
-                });
+            it('should only serialize id and last', function () {
+                var result,
+                    serializer = createSerializer(function (config) {
+                        this.only('id', 'last');
+                    });
 
-            result = serializer.serialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
-            expect(result).toEqualData({id: 1, last: 'Martin'});
-            result = serializer.deserialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
-            expect(result).toEqualData({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+                result = serializer.serialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+                expect(result).toEqualData({id: 1, last: 'Martin'});
+                result = serializer.deserialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+                expect(result).toEqualData({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+            });
         });
     });
 });