angularjs-rails-resource 0.2.0 → 0.2.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjM2MTM3OTRmYjQzZDE1ZGNhZjk1YTM2MDk4ZmUxNTJjMzBmYzBmOA==
+  data.tar.gz: !binary |-
+    NjAyYWZmZGEwNzQ2MjhmODk1OWIyMTRiMWY1NDBmOWQxN2VkMGQ3Ng==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MWU4ZDAzMjZhMGM5NTIyZmZlMzY4YjQ3M2I3MzJmMmI1MDI4ZWI2ZjE5NmZh
+    Njc5NzU0YzNkNjFlYjI2OGM1NzJlNDczOTQxOGU4ZDgwNDgzYzVjZjE2Yzgy
+    ODQyYWI4NTM3NGYyMWY0MDlmNjkyM2M0ZGQyOWY0NTEwM2E2Njc=
+  data.tar.gz: !binary |-
+    ODkyMTcyNmZhYjVjYmNlZWM3NTAzNjY4ZDYzYmU0Yjk3NGQxYjQyNzAxMWQy
+    ODE5NjQ4YmNiMmNhOTRjZGQyOGZjNjZkOTUyYzg3NWI5MmRiYjQ5ZDZjM2Fk
+    MGY5ZDM2YzZiNGZiZDNlYTdhMjA4M2UyNTZhMTYyMmQ4ODEwM2Q=

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+<a name="0.2.1"></a>
+# 0.2.1
+## Bug Fixes
+
+## Features
+- Added context property to before response interceptors to have access to the calling resource instance in the case of create/update/delete.
+- Added after response interceptors to be able to define custom callbacks that execute on all resources after method completion.
+
 <a name="0.2.0"></a>
 # 0.2.0
 ## Breaking Changes

data/EXAMPLES.md

@@ -13,12 +13,12 @@ a resource instance for the book.
         return railsResourceFactory({url: '/books', name: 'book'});
     }]);
 
-    angular.module('book.services').factory('Book', ['railsResourceFactory', function (railsResourceFactory) {
+    angular.module('book.services').factory('Author', ['railsResourceFactory', 'railsSerializer', function (railsResourceFactory, railsSerializer) {
         return railsResourceFactory({
             url: '/authors',
             name: 'author',
             serializer: railsSerializer(function () {
-                this.nestedResource('books', 'Book');
+                this.resource('books', 'Book');
             });
          });
     }]);
@@ -32,6 +32,50 @@ a resource instance for the book.
         }
     }]);
 
+# Nested attributes
+While we don't have logic for full nested attributes support, the new serializer does allow you to specify which fields
+should be passed with the <code>_attributes</code> suffix.
+
+    angular.module('book.services').factory('Book', ['railsResourceFactory', 'railsSerializer', function (railsResourceFactory, railsSerializer) {
+        return railsResourceFactory({
+            url: '/books',
+            name: 'book',
+            serializer: railsSerializer(function () {
+                this.nestedAttribute('author');
+            });
+         });
+    }]);
+
+# Excluding attributes from serialization
+Sometimes you don't want to serialize certain fields when updating an object.  Take for instance the case of the author on a book.
+We know that we don't accept nested attributes for the author on the server so we want to exclude it from the JSON to reduce
+the amount of data being sent to the server.
+
+    angular.module('book.services').factory('Book', ['railsResourceFactory', 'railsSerializer', function (railsResourceFactory railsSerializer) {
+        return railsResourceFactory({
+            url: '/books',
+            name: 'book',
+            serializer: railsSerializer(function () {
+                this.exclude('author');
+            });
+         });
+    }]);
+
+
+# Only allowing specific attributes for serialization
+You can also be very restrictive and only include specific attributes that you want to send to the server.  All other attribtues
+would be excluded by default.
+
+    angular.module('book.services').factory('Book', ['railsResourceFactory', 'railsSerializer', function (railsResourceFactory. railsSerializer) {
+        return railsResourceFactory({
+            url: '/books',
+            name: 'book',
+            serializer: railsSerializer(function () {
+                this.only('id', 'isbn', 'publicationDate');
+            });
+         });
+    }]);
+
 
 # Adding custom methods to a resource
 You can add additional "class" or "instance" methods by modifying the resource returned from the factory call.
@@ -97,7 +141,7 @@ passes the resulting promise to the processResponse method which will perform th
     }]);
 
 # Specifying Transformer
-Transformers can be by specifying an array of transformers in the configuration options passed to railsResourceFactory.
+Transformers can be specified by an array of transformers in the configuration options passed to railsResourceFactory.
 However, a cleaner eway to write it is to use the <code>beforeRequest</code> which can take a new anonymous function or
 a function returned by a factory if you want to share a transformer across multiple resources.
 

data/README.md

@@ -87,7 +87,7 @@ When defining a resource, you can pass a custom [serializer](#serializers) using
         serializer: railsSerializer(function () {
             this.exclude('birthDate', 'books');
             this.nestedAttribute('books');
-            this.nestedResource('books', 'Book');
+            this.resource('books', 'Book');
         })
     });
 
@@ -134,6 +134,7 @@ The following options are available for the config object passed to the factory
  * **defaultParams** *(optional)* - If the resource expects a default set of query params on every call you can specify them here.
  * **requestTransformers** *(optional) - See [Transformers / Interceptors](#transformers--interceptors)
  * **responseInterceptors** *(optional)* - See [Transformers / Interceptors](#transformers--interceptors)
+ * **afterResponseInterceptors** *(optional)* - See [Transformers / Interceptors](#transformers--interceptors)
 
 **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".
@@ -203,12 +204,16 @@ passed to the function is still a Resource instance as long as another transform
         * **resource** {Resource class} - The Resource class that is calling the function
         * **returns** {object | undefined} - If the function returns a new object that object will instead be used for serialization.
 
-* beforeResponse(fn(data, resource)) - See [Interceptors](#interceptors) for more information.  The function is called prior to deserialization so the data represents the
-raw data returned from the server.  Since the data has not been deserialized into a Resource instance yet, none of the [Resource instance methods](#instance-methods) are available.
-    * fn(data, resource) {function} - The function to add as an interceptor
+* beforeResponse(fn(data, resource, context)) - See [Interceptors](#interceptors) for more information.  The function is called after the response data has been deserialized.
+    * fn(data, resource, context) {function} - The function to add as an interceptor
         * **data** {object} - The data received from the server
-        * **resource** {Resource class} - The Resource class that is calling the function
-        * **returns** {object | undefined} - If the function returns a new object that object will instead be used for serialization.
+        * **resource** {Resource function} - The Resource constructor that is calling the function
+        * **context** {Resource|undefined} - The Resource instance that is calling the function or undefined if called from a class level method (get, query).
+
+* afterResponse(fn(data, resource, context)) - See [Interceptors](#interceptors) for more information.  This function is called after all internal processing and beforeResponse callbacks have been completed.
+    * fn(data, resource) {function} - The function to add as an interceptor
+        * **data** {object} - The result, either an array of resource instances or a single resource instance.
+        * **resource** {Resource function} - The Resource constructor that is calling the function
 
 ### Instance Methods
 The instance methods can be used on any instance (created manually or returned in a promise response) of a resource.
@@ -244,6 +249,8 @@ that dictate how serialization and deserialization is performed.  Users can: ren
 with the ability to exclude all attributes by default and only serialize ones explicitly allowed, specify other serializers to use
 for an attribute and even specify that an attribute is a nested resource.
 
+AngularJS automatically excludes all attribute keys that begin with $ in their toJson code.
+
 ### railsSerializer
 * railsSerializer(options, customizer) - Builds a Serializer constructor function using the configuration options specified.
     * **options** {object} (optional) - Configuration options to alter the default operation of the serializers.  This parameter can be excluded and the
@@ -274,7 +281,7 @@ Serializers have the following available configuration options:
     * **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.  For instance, $resource excludes all variables that start with $.  The values in the array can be one of the following types:
+* 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.
@@ -292,7 +299,7 @@ The customizer function passed to the railsSerializer has available to it the fo
 
 * resource (attributeName, resource, serializer) - 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.
 
-* add (attributeName, value) - Allows custom attribute creation as part of the serialization to JSON.  This method may be renamed to allow for specifying different custom attributes during serialization to allow for custom attributes during deserialization as well.  The parameter <code>value</code> can be defined as function that takes a parameter of the containing object and returns a value that should be included in the JSON.
+* add (attributeName, value) - Allows custom attribute creation as part of the serialization to JSON.  The parameter <code>value</code> can be defined as function that takes a parameter of the containing object and returns a value that should be included in the JSON.
 
 * serializeWith (attributeName, serializer) - Specifies a custom serializer that should be used for the attribute.  The serializer can be specified either as a <code>string</code> reference to a registered service or as a Serializer constructor returned from <code>railsSerializer</code>
 
@@ -306,7 +313,7 @@ The transformers and interceptors can be specified using an array containing tra
 that can be resolved using Angular's DI.  The transformers / interceptors concept was prior to the [serializers](#serializers) but
 we kept the API available because there may be use cases that can be accomplished with these but not the serializers.
 
-### Transformers
+### Request Transformers
 Transformer functions are called to transform the data before we send it to $http for POST/PUT.
 
 A transformer function is called with two parameters:
@@ -319,17 +326,32 @@ The resource also exposes a class method <code>beforeRequest(fn)</code> that acc
 to the list of transformers for the resource class.  The function passed to <code>beforeRequest</code> is called with the same two parameters.  One difference
 is that the functions are not required to return the data, though they still can if they need to return a new object.  See [example](EXAMPLES.md#specifying-transformer).
 
-### Interceptors
+### Response Interceptors
 Interceptor functions utilize [$q promises](http://docs.angularjs.org/api/ng.$q) to process the data returned from the server.
 
 The interceptor is called with the promise returned from $http and is expected to return a promise for chaining.  The promise passed to each
-interceptor contains a reference to the resource to expose the configured options of the resource.  Each interceptor promise
-is expected to return the response or a $q.reject.  See [Promises](#promises) for more information about the promise data.
+interceptor contains two additional properties:
+  * **resource** - The Resource constructor function for the resource calling the interceptor
+  * **context** - The Resource instance if applicable (create, update, delete) calling the interceptor
+
+Each interceptor promise is expected to return the response or a $q.reject.  See [Promises](#promises) for more information about the promise data.
 
 The resource also exposes a class method <code>beforeResponse(fn)</code> that accepts a function to execute and automatically wraps it as an interceptor and appends it
-to the list of interceptors for the resource class.  Functions added with beforeResponse don't need to know anything about promises since they are automatically wrapped
+to the list of interceptors for the resource class.  Functions added with <code>beforeResponse</code> don't need to know anything about promises since they are automatically wrapped
 as an interceptor.
 
+### After Response Interceptors
+After response interceptors are called after all processing and response interceptors have completed.  An after response interceptor is analogous to
+chaining a promise after the resource method call but is instead for all methods.
+
+The after response interceptors are called with the final processing promise and is expected to return a promise for chaining.  The promise is resolved
+with the result of the operation which will be either a resource instance or an array of resource instances.  The promise passed to the interceptor
+has the following additional property:
+ * **resource** - The Resource constructor function for the resource calling the interceptor
+
+The resource also exposes a class method <code>afterResponse(fn)</code> that accepts a function to execute and automatically wraps it as an interceptor and appends it
+to the list of after response interceptors for the resource class.  Functions added with <code>afterResponse</code> don't need to know anything about promises since they are automatically wrapped
+as an interceptor.
 
 ## Tests
 The tests are written using [Jasmine](http://pivotal.github.com/jasmine/) and are run using [Karma](https://github.com/karma-runner/karma).

data/karma.conf.js

@@ -1,22 +1,22 @@
-basePath = './';
-
-files = [
-  JASMINE,
-  JASMINE_ADAPTER,
-  'test/lib/angular/angular.js',
-  'test/lib/angular/angular-bootstrap.js',
-  'test/lib/angular/angular-loader.js',
-  'test/lib/angular/angular-sanitize.js',
-  'test/lib/angular/angular-mocks.js',
-  'vendor/assets/javascripts/**/*.js',
-  'test/unit/**/*.js'
-];
-
-autoWatch = true;
-
-browsers = ['Chrome'];
-
-junitReporter = {
-  outputFile: 'test_out/unit.xml',
-  suite: 'unit'
+module.exports = function(config) {
+  config.set({
+    basePath: '.',
+    autoWatch: true,
+    browsers: ['Chrome'],
+    frameworks: ['jasmine'],
+    reporters: ['progress', 'junit'],
+    files: [
+      'test/lib/angular/angular.js',
+      'test/lib/angular/angular-bootstrap.js',
+      'test/lib/angular/angular-loader.js',
+      'test/lib/angular/angular-sanitize.js',
+      'test/lib/angular/angular-mocks.js',
+      'vendor/assets/javascripts/**/*.js',
+      'test/unit/**/*.js'
+    ],
+    junitReporter: {
+        outputFile: 'test_out/unit.xml',
+        suite: 'unit'
+    }
+  })
 };

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

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

data/package.json

@@ -2,10 +2,15 @@
   "name": "angularjs-rails-resource",
   "version": "0.0.0",
   "dependencies": {
-    "karma": "~0.8"
   },
   "scripts": {
-   "test": "./node_modules/.bin/karma start --single-run --browsers PhantomJS"
+    "test": "./node_modules/.bin/karma start --single-run --browsers PhantomJS"
+  },
+  "devDependencies": {
+    "karma": "~0.10",
+    "karma-jasmine": "~0.1",
+    "karma-chrome-launcher": "~0.1",
+    "karma-phantomjs-launcher": "~0.1",
+    "karma-junit-reporter": "~0.1"
   }
 }
-

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

@@ -1,12 +1,12 @@
 describe('transformers', function () {
     'use strict';
-    var $httpBackend, $rootScope, factory, Test, testInterceptor,
+    var $httpBackend, $rootScope, factory, Test, testInterceptor, testAfterInterceptor,
         config = {
             url: '/test',
             name: 'test'
         };
 
-    beforeEach(function() {
+    beforeEach(function () {
         module('rails');
 
         angular.module('rails').factory('railsTestInterceptor', function () {
@@ -17,89 +17,219 @@ describe('transformers', function () {
                 });
             }
         });
+
+        angular.module('rails').factory('railsTestAfterInterceptor', function () {
+            return function (promise) {
+                return promise.then(function (resource) {
+                    resource.interceptorAdded = 'x';
+                    return resource;
+                });
+            }
+        });
     });
 
-    beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory, railsTestInterceptor) {
+    beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory, railsTestInterceptor, railsTestAfterInterceptor) {
         $httpBackend = _$httpBackend_;
         $rootScope = _$rootScope_;
         factory = railsResourceFactory;
         Test = railsResourceFactory(config);
         testInterceptor = railsTestInterceptor;
+        testAfterInterceptor = railsTestAfterInterceptor;
     }));
 
-    afterEach(function() {
+    afterEach(function () {
         $httpBackend.verifyNoOutstandingExpectation();
         $httpBackend.verifyNoOutstandingRequest();
     });
 
+    describe('before response', function () {
+        it('should be able to reference interceptor using name', function () {
+            var promise, result, Resource, testConfig = {};
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
 
-    it('should be able to reference interceptor using name', function() {
-        var promise, result, Resource, testConfig = {};
+            angular.copy(config, testConfig);
+            testConfig.responseInterceptors = ['railsTestInterceptor'];
+            Resource = factory(testConfig);
 
-        $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+            expect(promise = Resource.get(123)).toBeDefined();
 
-        angular.copy(config, testConfig);
-        testConfig.responseInterceptors = ['railsTestInterceptor'];
-        Resource = factory(testConfig);
+            promise.then(function (response) {
+                result = response;
+            });
 
-        expect(promise = Resource.get(123)).toBeDefined();
+            $httpBackend.flush();
 
-        promise.then(function (response) {
-            result = response;
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
         });
 
-        $httpBackend.flush();
+        it('should be able to add interceptor using reference', function () {
+            var promise, result, Resource, testConfig = {};
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+
+            angular.copy(config, testConfig);
+            testConfig.responseInterceptors = [testInterceptor];
+            Resource = factory(testConfig);
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
+        });
+
+        it('should be able to add interceptor using beforeResponse', function () {
+            var promise, result, Resource, interceptorCalled = false;
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
+
+            Resource.beforeResponse(function (resource, constructor, context) {
+                expect(resource).toEqualData({id: 123, abcDef: 'xyz'});
+                expect(constructor).toEqual(Resource);
+                expect(context).toBeUndefined();
+                interceptorCalled = true;
+            });
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({id: 123, abcDef: 'xyz'});
+            expect(interceptorCalled).toBeTruthy();
+        });
+
+        it('should set context to resource instance', function () {
+            var instance, Resource, interceptorCalled = false;
+
+            $httpBackend.expectPOST('/test').respond(200, {id: 123, abc_def: 'xyz'});
 
-        expect(result).toBeInstanceOf(Resource);
-        expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
+            Resource = factory(config);
+
+            instance = new Resource({abcDef: 'xyz'});
+
+            Resource.beforeResponse(function (resource, constructor, context) {
+                expect(resource).toEqualData({id: 123, abcDef: 'xyz'});
+                expect(constructor).toEqual(Resource);
+                expect(context).toBeInstanceOf(Resource);
+                expect(context).toEqualData(instance);
+                interceptorCalled = true;
+            });
+
+            instance.save();
+
+            $httpBackend.flush();
+
+            expect(interceptorCalled).toBeTruthy();
+        });
     });
 
-    it('should be able to add interceptor using reference', function() {
-        var promise, result, Resource, testConfig = {};
+    describe('after response', function () {
+        it('should be able to reference interceptor using name', function () {
+            var promise, result, Resource, testConfig = {};
 
-        $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
 
+            angular.copy(config, testConfig);
+            testConfig.afterResponseInterceptors = ['railsTestAfterInterceptor'];
+            Resource = factory(testConfig);
 
-        angular.copy(config, testConfig);
-        testConfig.responseInterceptors = [testInterceptor];
-        Resource = factory(testConfig);
+            expect(promise = Resource.get(123)).toBeDefined();
 
-        expect(promise = Resource.get(123)).toBeDefined();
+            promise.then(function (response) {
+                result = response;
+            });
 
-        promise.then(function (response) {
-            result = response;
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
         });
 
-        $httpBackend.flush();
+        it('should be able to add interceptor using reference', function () {
+            var promise, result, Resource, testConfig = {};
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
 
-        expect(result).toBeInstanceOf(Resource);
-        expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
-    });    
-    
-    it('should be able to add interceptor using beforeResponse', function() {
-        var promise, result, Resource, interceptorCalled = false;
+            angular.copy(config, testConfig);
+            testConfig.afterResponseInterceptors = [testAfterInterceptor];
+            Resource = factory(testConfig);
 
-        $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+            expect(promise = Resource.get(123)).toBeDefined();
 
-        Resource = factory(config);
+            promise.then(function (response) {
+                result = response;
+            });
 
-        Resource.beforeResponse(function (resource, constructor) {
-            expect(resource).toEqualData({id: 123, abcDef: 'xyz'});
-            expect(constructor).toEqual(Resource);
-            interceptorCalled = true;
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
         });
 
-        expect(promise = Resource.get(123)).toBeDefined();
+        it('should be able to add interceptor using afterResponse', function () {
+            var promise, result, Resource, interceptorCalled = false;
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
 
-        promise.then(function (response) {
-            result = response;
+            Resource.afterResponse(function (resource, constructor, context) {
+                expect(resource).toEqualData({id: 123, abcDef: 'xyz'});
+                expect(constructor).toEqual(Resource);
+                interceptorCalled = true;
+            });
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({id: 123, abcDef: 'xyz'});
+            expect(interceptorCalled).toBeTruthy();
         });
 
-        $httpBackend.flush();
+        it('should set context to resource instance', function () {
+            var instance, Resource, interceptorCalled = false;
+
+            $httpBackend.expectPOST('/test').respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
 
-        expect(result).toBeInstanceOf(Resource);
-        expect(result).toEqualData({id: 123, abcDef: 'xyz'});
-        expect(interceptorCalled).toBeTruthy();
+            instance = new Resource({abcDef: 'xyz'});
+
+            Resource.afterResponse(function (resource, constructor, context) {
+                expect(resource).toEqualData({id: 123, abcDef: 'xyz'});
+                expect(constructor).toEqual(Resource);
+                interceptorCalled = true;
+            });
+
+            instance.save();
+
+            $httpBackend.flush();
+
+            expect(interceptorCalled).toBeTruthy();
+        });
     });
 
+
 });

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

@@ -32,7 +32,8 @@
 
         function railsResourceFactory(config) {
             var transformers = config.requestTransformers,
-                interceptors = config.responseInterceptors;
+                interceptors = config.responseInterceptors,
+                afterInterceptors = config.afterResponseInterceptors;
 
             function appendPath(url, path) {
                 if (path) {
@@ -47,19 +48,21 @@
             }
 
             function RailsResource(value) {
+                var instance = this;
                 if (value) {
                     var immediatePromise = function(data) {
                       return {
                           resource: RailsResource,
+                          context: instance,
                           response: data,
                           then: function(callback) {
-                            this.response = callback(this.response, this.resource);
+                            this.response = callback(this.response, this.resource, this.context);
                             return immediatePromise(this.response);
                           }
                         }
                     };
 
-                    var data = RailsResource.callInterceptors(immediatePromise({data: value})).response.data;
+                    var data = RailsResource.callInterceptors(immediatePromise({data: value}), this).response.data;
                     angular.extend(this, data);
                 }
             }
@@ -74,6 +77,7 @@
             RailsResource.httpConfig.headers = angular.extend({'Accept': 'application/json', 'Content-Type': 'application/json'}, RailsResource.httpConfig.headers || {});
             RailsResource.requestTransformers = [];
             RailsResource.responseInterceptors = [];
+            RailsResource.afterResponseInterceptors = [];
             RailsResource.defaultParams = config.defaultParams;
             RailsResource.serializer = RailsResourceInjector.createService(config.serializer || railsSerializer());
             RailsResource.rootName = RailsResource.serializer.underscore(config.name);
@@ -81,13 +85,29 @@
 
             /**
              * Add a callback to run on response and construction.
-             * @param fn(resource, constructor) - resource is a resource instance, and constructor is the resource class calling the function
+             * @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) {
-              var fn = RailsResourceInjector.getDependency(fn);
+              fn = RailsResourceInjector.getDependency(fn);
               RailsResource.responseInterceptors.push(function(promise) {
                 return promise.then(function(response) {
-                    fn(response.data, promise.resource);
+                    fn(response.data, promise.resource, promise.context);
+                    return response;
+                });
+              });
+            };
+
+            /**
+             * Add a callback to run after response has been processed.  These callbacks are not called on object construction.
+             * @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);
+              RailsResource.afterResponseInterceptors.push(function(promise) {
+                return promise.then(function(response) {
+                    fn(response, promise.resource);
                     return response;
                 });
               });
@@ -98,7 +118,7 @@
              * @param fn (data, constructor) - data object is the serialized resource instance, and constructor the resource class calling the function
              */
             RailsResource.beforeRequest = function(fn) {
-              var fn = RailsResourceInjector.getDependency(fn);
+              fn = RailsResourceInjector.getDependency(fn);
               RailsResource.requestTransformers.push(function(data, resource) {
                 return fn(data, resource) || data;
               });
@@ -109,6 +129,10 @@
                 RailsResource.responseInterceptors.push(RailsResourceInjector.getDependency(interceptor));
             });
 
+            angular.forEach(afterInterceptors, function (interceptor) {
+                RailsResource.afterResponseInterceptors.push(RailsResourceInjector.getDependency(interceptor));
+            });
+
             angular.forEach(transformers, function (transformer) {
                 RailsResource.requestTransformers.push(RailsResourceInjector.getDependency(transformer));
             });
@@ -131,7 +155,7 @@
             };
 
             // transform data on response:
-            RailsResource.callInterceptors = function (promise) {
+            RailsResource.callInterceptors = function (promise, context) {
                 promise = promise.then(function (response) {
                     // store off the data in case something (like our root unwrapping) assigns data as a new object
                     response.originalData = response.data;
@@ -150,6 +174,18 @@
 
                 // data is now deserialized. call response interceptors including beforeResponse
                 angular.forEach(RailsResource.responseInterceptors, function (interceptor) {
+                    promise.resource = RailsResource;
+                    promise.context = context;
+                    promise = interceptor(promise);
+                });
+
+                return promise;
+            };
+
+            // transform data after response has been converted to a resource instance:
+            RailsResource.callAfterInterceptors = function (promise) {
+                // data is now deserialized. call response interceptors including afterResponse
+                angular.forEach(RailsResource.afterResponseInterceptors, function (interceptor) {
                     promise.resource = RailsResource;
                     promise = interceptor(promise);
                 });
@@ -158,9 +194,11 @@
             };
 
             RailsResource.processResponse = function (promise) {
-                return RailsResource.callInterceptors(promise).then(function (response) {
+                promise = RailsResource.callInterceptors(promise).then(function (response) {
                     return response.data;
                 });
+
+                return RailsResource.callAfterInterceptors(promise);
             };
 
             RailsResource.getParameters = function (queryParams) {
@@ -233,9 +271,9 @@
             };
 
             RailsResource.prototype.processResponse = function (promise) {
-                promise = RailsResource.callInterceptors(promise);
+                promise = RailsResource.callInterceptors(promise, this);
 
-                return promise.then(angular.bind(this, function (response) {
+                promise = promise.then(angular.bind(this, function (response) {
                     // we may not have response data
                     if (response.hasOwnProperty('data') && angular.isObject(response.data)) {
                         angular.extend(this, response.data);
@@ -243,6 +281,8 @@
 
                     return this;
                 }));
+
+                return RailsResource.callAfterInterceptors(promise);
             };
 
             angular.forEach(['post', 'put', 'patch'], function (method) {

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

@@ -4,7 +4,7 @@
             underscore: RailsInflector.underscore,
             camelize: RailsInflector.camelize,
             pluralize: RailsInflector.pluralize,
-            exclusionMatchers: ['$'],
+            exclusionMatchers: [],
             excludeByDefault: false
         };
 

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: angularjs-rails-resource
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.2.1
 platform: ruby
 authors:
 - Tommy Odom
@@ -10,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-06 00:00:00.000000000 Z
+date: 2013-08-08 00:00:00.000000000 Z
 dependencies: []
 description: A small AngularJS add-on for integrating with Rails via JSON more easily.
 email:
@@ -62,27 +61,26 @@ files:
 - vendor/assets/javascripts/angularjs/rails/resource/utils/url_builder.js
 homepage: https://github.com/finelineprototyping/angularjs-rails-resource
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ''
 test_files:
 - test/lib/angular/angular-bootstrap-prettify.js