angularjs-rails-resource 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4bfbacbc10e68b92315a301e1419852f77b4c028
-  data.tar.gz: 73c370919edead2bd08430a3551513196595389d
+  metadata.gz: 168a47c7cf77844625f4f730eb0a9f3c870618d7
+  data.tar.gz: ad71d9b538c88d7fb0c3ffb251ef94a44ebff3db
 SHA512:
-  metadata.gz: 11b7134336f0441bdd6ee5cec43b5d683f82d1d1e965d55f50a174c69eca431ee7b927dc903bb43f57f1038fcd5fd75a54734ffb46cfa53c7a62bc27f8b30bc7
-  data.tar.gz: 805dbd40dcc11ce20b3773c04fb974a5b2b2ae2c5f6a0e452a455c1c222da60f32ff3b8378413d5f12fe4dcaf530bb030beae592741e3889dce3a556b86b53f3
+  metadata.gz: b02702b23f89ddc927d956dde10aff6c5165dd0fff11da4258179384dede75429a172a3c56ed07495a8d4b24f2c60245dd37bb565500da3dda0c713ca66db4ba
+  data.tar.gz: 9bddfe4eaf76e420b5a7696e2120086218c2938d686802297889c0edc7cebd441f5b0eda161807c7f339b5b8020acd46f292dc667faa5cec4e5c136a02c0adf3

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+<a name="1.2.0"></a>
+# 1.2.0
+## Bug Fixes
+
+## Features
+- Added <code>unsnappedChanges()</code> function to snapshots mixin to check whether or not there have been any changes since the last snapshot was taken. - #125 (@StevenClontz)
+- Added <code>skipRequestProcessing</code> override configuration option to $http, $post, $put, $patch to bypass request processing (root wrapping, serialization) and request interceptor chains - #123 (@mayhewluke) 
+
 <a name="1.1.0"></a>
 # 1.1.0
 ## Bug Fixes

data/EXAMPLES.md

@@ -133,7 +133,7 @@ passes the resulting promise to the processResponse method which will perform th
 		var resource = railsResourceFactory({url: '/books', name: 'book'});
 		resource.prototype.getReferences = function () {
 			var self = this;
-			return resource.$get(self.$url('references'))).then(function (references) {
+			return resource.$get(self.$url('references')).then(function (references) {
 				self.references = references;
 				return self.references;
 			});
@@ -142,7 +142,7 @@ passes the resulting promise to the processResponse method which will perform th
 
 # Specifying Transformer
 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
+However, a cleaner way 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.
 
 Both of these examples can be accomplished using the serializers now.

data/README.md

@@ -35,7 +35,7 @@ angular.module('app').config(["railsSerializerProvider", function(railsSerialize
 ### Rails Asset Pipeline
 Add this line to your application's Gemfile to use the latest stable version:
 ```ruby
-gem 'angularjs-rails-resource', '~> 1.0.0'
+gem 'angularjs-rails-resource', '~> 1.1.1'
 ```
 
 Include the javascript somewhere in your asset pipeline:
@@ -298,9 +298,10 @@ RailsResources have the following class methods available.
     * **queryParams** {object} (optional) - The set of query parameters to include in the GET request
     * **returns** {promise} A promise that will be resolved with a new Resource instance (or instances in the case of an array response).
 
-* $post(customUrl, data), $put(customUrl, data), $patch(customUrl, data) - Serializes the data parameter using the Resource's normal serialization process and submits the result as a POST / PUT / PATCH to the given URL.
+* $post/$put/$patch(customUrl, data, resourceConfigOverrides) - Serializes the data parameter using the Resource's normal serialization process and submits the result as a POST / PUT / PATCH to the given URL.
     * **customUrl** {string} - The url to POST / PUT / PATCH to
     * **data** {object} - The data to serialize and POST / PUT / PATCH
+    * **resourceConfigOverrides** {object} (optional) - An optional set of RailsResource configuration option overrides to use for this request. Root wrapping and serialization for the request data can be bypassed using the `skipRequestProcessing` flag. This also bypasses the entire pre-request [interceptor](#interceptors) chain.
     * **returns** {promise} A promise that will be resolved with a new Resource instance (or instances in the case of an array response).
 
 * $delete(customUrl, queryParams) - Executes a DELETE to a custom URL.  The main difference between this and $http.delete is that a server response that contains a body will be deserialized using the normal Resource deserialization process.
@@ -311,7 +312,7 @@ RailsResources have the following class methods available.
 * $http(httpConfig, context, resourceConfigOverrides) - Executes an HTTP operation specified by the config.  The request data is serialized and root wrapped (if configured).  The response data is unwrapped (if configured) and deserialized and copied to the context object if specified.
   * **httpConfig** {object} - Standard $http config object.
   * **context** {object} - The instance that the operation is being run against.
-  * **resourceConfigOverrides** {object} - An optional set of RailsResource configuration option overrides to use for this request.
+  * **resourceConfigOverrides** {object} (optional) - An optional set of RailsResource configuration option overrides to use for this request. Root wrapping and serialization for the request data can be bypassed using the `skipRequestProcessing` flag. This also bypasses the entire pre-request [interceptor](#interceptors) chain.
 
 * addInterceptor(interceptor) - Adds an interceptor to the resource class.
   * **interceptor** {object | string} - See [Interceptors](#interceptors) for details of object format.
@@ -327,7 +328,7 @@ RailsResources have the following class methods available.
 * interceptResponse - Shortcut for intercept('response', callback)
 * interceptAfterResponse - Shortcut for intercept('afterResponse', callback)
 
-**Deprecated** 
+**Deprecated**
 * beforeRequest(fn(data, resource)) - See [Interceptors](#interceptors) for more information.  The function is called prior to the serialization process so the data
 passed to the function is still a Resource instance as long as another transformation function has not returned a new object to serialize.
     * fn(data, resource) {function} - The function to add as a transformer.
@@ -459,7 +460,7 @@ Interceptors are similar in design to the $http interceptors.  You can add inter
 
 There are several phases for both request and response to give users and mixins more flexibility for exactly where they want to insert a customization.  Each phase also has a corresponding error phase which is the phase name appended with Error (e.g. beforeResponse and beforeResponseError).  The error phases receive the current rejection value which in most cases would be the error returned from $http.  Since these are $q promises, your interceptor can decide whether or not to propagate the error or recover from it.  If you want to propagate the error, you must return a <code>$q.reject(reason)</code> result.  Otherwise any value you return will be treated as a successful value to use for the rest of the chain.  For instance, in the <code>beforeResponseError</code> phase you could attempt to recover by using an alternate URL for the request data and return the new promise as the result.
 
-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.  
+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:
 
@@ -501,7 +502,7 @@ angular.module('rails').factory('saveIndicatorInterceptor', function () {
             if (context) {
                 context.savePending = false;
             }
-            return result;                    
+            return result;
         },
         'afterResponseError': function (rejection, resourceConstructor, context) {
             if (context) {
@@ -512,7 +513,7 @@ angular.module('rails').factory('saveIndicatorInterceptor', function () {
     };
 });
 ```
-  
+
 ## Transformers / Interceptors (**DEPRECATED**)
 The transformers and interceptors can be specified using an array containing transformer/interceptor functions or strings
 that can be resolved using Angular's DI.  The transformers / interceptors concept was prior to the [serializers](#serializers) but
@@ -671,6 +672,14 @@ snapshot version.  <code>numVersions</code> can be used to roll back further tha
 * When <code>snapshotVersion</code> is less than 0 then the resource will be rolled back to the first version.
 * Otherwise, the resource will be rolled back to the specific version specified.
 
+##### unsnappedChanges
+`unsnappedChanges()` checks to see if the resource has been changed since its last snapshot
+
+* If there are no snapshots, returns `true`
+* If all properties considered by `angular.equals` match the latest snapshot, returns `false`;
+  otherwise, returns `true`
+* (Note that `angular.equals` [does not consider $-prefixed properties](https://docs.angularjs.org/api/ng/function/angular.equals))
+
 ## Tests
 The tests are written using [Jasmine](http://pivotal.github.com/jasmine/) and are run using [Karma](https://github.com/karma-runner/karma).
 

data/bower.json

@@ -1,6 +1,6 @@
 {
   "name": "angularjs-rails-resource",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "main": "angularjs-rails-resource.js",
   "description": "A resource factory inspired by $resource from AngularJS",
   "repository": {

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

@@ -1,7 +1,7 @@
 module Angularjs
   module Rails
     module Resource
-      VERSION = '1.1.1'
+      VERSION = '1.2.0'
     end
   end
 end

data/package.json

@@ -1,7 +1,7 @@
 {
   "name": "angularjs-rails-resource",
   "description" : "A resource factory inspired by $resource from AngularJS",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "main" : "dist/angularjs-rails-resource.min.js",
   "homepage" : "https://github.com/FineLinePrototyping/angularjs-rails-resource.git",
   "author" : "",

data/test/unit/angularjs/rails/extensions/snapshotsSpec.js

@@ -348,6 +348,31 @@ describe('RailsResource.snapshots', function () {
         expect(secondCallbackCalled).toBe(true);
     });
 
+    it('should detect unsnapped changes', function () {
+        var book, data = {id: 1, $key: '1234', name: 'The Winds of Winter', theAuthor: 'George R.R. Martin'};
+        book = new Book(data);
+        expect(book.unsnappedChanges()).toBe(true);
+
+        book.snapshot();
+        expect(book.unsnappedChanges()).toBe(false);
+
+        book.name = 'Harry Potter';
+        expect(book.unsnappedChanges()).toBe(true);
+
+        book.snapshot();
+        expect(book.unsnappedChanges()).toBe(false);
+
+        book.theAuthor = 'J.K. Rowling';
+        expect(book.unsnappedChanges()).toBe(true);
+
+        book.snapshot();
+        expect(book.unsnappedChanges()).toBe(false);
+
+        // angular.equals ignores $-prefixed properties
+        book.$key = '1235'
+        expect(book.unsnappedChanges()).toBe(false);
+    });
+
     describe('serializer', function () {
         beforeEach(function () {
             Book.configure({

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

@@ -34,6 +34,92 @@ describe('http setting', function () {
         };
     }
 
+    describe('$post/$put/$patch', function() {
+
+        it('passes resourceConfigOverrides to $http', function() {
+            var methods = ['$post', '$put', '$patch'],
+                Resource = factory(config),
+                overrides = {baz: 'qux'};
+            spyOn(Resource, '$http');
+            angular.forEach(methods, function(method) {
+                Resource[method](null, null, overrides);
+                expect(Resource.$http.mostRecentCall.args[2]).toEqual(overrides);
+            });
+            expect(Resource.$http.calls.length).toBe(methods.length);
+        });
+
+    });
+
+    describe('$http', function() {
+
+        describe('when config includes skipRequestProcessing', function() {
+
+            it('skips all "before" interceptors', function() {
+                var phases = ['beforeRequest', 'beforeRequestWrapping', 'request'],
+                    interceptors = {},
+                    Resource = factory(config),
+                    data = {foo: 'bar'},
+                    httpConfig = {method: 'POST', url: config.url, data: data};
+
+                angular.forEach(phases, function(phase) {
+                    interceptors[phase] = jasmine.createSpy(phase);
+                    Resource.intercept(phase, interceptors[phase]);
+                });
+
+                $httpBackend.expectPOST(config.url, data).respond(200);
+                Resource.$http(httpConfig, null, {skipRequestProcessing: true});
+                $httpBackend.flush();
+
+                angular.forEach(phases, function(phase) {
+                    expect(interceptors[phase]).not.toHaveBeenCalled();
+                });
+            });
+
+            it('does not skip "after" interceptors', function() {
+                var phases = ['beforeResponse', 'beforeResponseDeserialize', 'response', 'afterResponse'],
+                    interceptors = {},
+                    Resource = factory(config),
+                    data = {foo: 'bar'},
+                    httpConfig = {method: 'POST', url: config.url, data: data};
+
+                angular.forEach(phases, function(phase) {
+                    interceptors[phase] = jasmine.createSpy(phase);
+                    Resource.intercept(phase, interceptors[phase]);
+                });
+
+                $httpBackend.expectPOST(config.url, data).respond(200);
+                Resource.$http(httpConfig, null, {skipRequestProcessing: true});
+                $httpBackend.flush();
+
+                angular.forEach(phases, function(phase) {
+                    expect(interceptors[phase]).toHaveBeenCalled();
+                });
+            });
+
+            it('deserializes the response into a Resource object', function() {
+
+                var promise,
+                    result,
+                    data = {foo: 'bar'},
+                    httpConfig = {method: 'POST', url: config.url, data: data},
+                    Resource = factory(config);
+
+                $httpBackend.expectPOST(config.url, data).respond(200, data);
+                promise = Resource.$http(httpConfig, null, {skipRequestProcessing: true});
+                promise.then(function(response) {
+                    result = response;
+                });
+                $httpBackend.flush();
+
+                expect(result).toBeInstanceOf(Resource);
+                expect(result).toEqualData(data);
+
+            });
+
+        });
+
+    });
+
     it('query should pass default $http options', inject(function($httpBackend) {
         var promise, result, Test;
 
@@ -236,4 +322,4 @@ describe('http setting', function () {
         $httpBackend.flush();
     }));
 
-});
+});

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

@@ -521,6 +521,36 @@ describe('railsResourceFactory', function () {
             data.$delete('/test', {a: 1});
             $httpBackend.flush();
         });
+
+        it('should return true for isNew when id undefined', function () {
+            expect(new Test().isNew()).toBeTruthy();
+        });
+
+        it('should return true for isNew when id is null', function () {
+            expect(new Test({id: null}).isNew()).toBeTruthy();
+        });
+
+        it('should return false for isNew when id is set', function () {
+            expect(new Test({id: 1}).isNew()).toBeFalsy();
+        });
+
+        describe('overridden idAttribute', function () {
+            beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory) {
+                Test = railsResourceFactory({url: '/test', name: 'test', idAttribute: 'xyz'});
+            }));
+
+            it('should return true for isNew when xyz undefined', function () {
+                expect(new Test().isNew()).toBeTruthy();
+            });
+
+            it('should return true for isNew when xyz is null', function () {
+                expect(new Test({xyz: null}).isNew()).toBeTruthy();
+            });
+
+            it('should return false for isNew when xyz is set', function () {
+                expect(new Test({xyz: 1}).isNew()).toBeFalsy();
+            });
+        });
     });
 
     describe('plural', function() {

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

@@ -17,24 +17,37 @@
             Resource.include({
                 snapshot: snapshot,
                 rollback: rollback,
-                rollbackTo: rollbackTo
+                rollbackTo: rollbackTo,
+                unsnappedChanges: unsnappedChanges,
+                _prepSnapshot: _prepSnapshot
             });
         };
 
         return RailsResourceSnapshotsMixin;
 
         /**
-         * Stores a copy of this resource in the $snapshots array to allow undoing changes.
-         * @param {function} rollbackCallback Optional callback function to be executed after the rollback.
-         * @returns {Number} The version of the snapshot created (0-based index)
+         * Prepares a copy of the resource to be stored as a snapshot
+         * @returns {Resource} the copied resource, sans $snapshots
          */
-        function snapshot(rollbackCallback) {
+        function _prepSnapshot() {
             var config = this.constructor.config,
                 copy = (config.snapshotSerializer || config.serializer).serialize(this);
 
             // we don't want to store our snapshots in the snapshots because that would make the rollback kind of funny
             // not to mention using more memory for each snapshot.
             delete copy.$snapshots;
+
+            return copy
+        }
+
+        /**
+         * Stores a copy of this resource in the $snapshots array to allow undoing changes.
+         * @param {function} rollbackCallback Optional callback function to be executed after the rollback.
+         * @returns {Number} The version of the snapshot created (0-based index)
+         */
+        function snapshot(rollbackCallback) {
+            var copy = this._prepSnapshot();
+
             copy.$rollbackCallback = rollbackCallback;
 
             if (!this.$snapshots) {
@@ -116,5 +129,20 @@
             return true;
         }
 
+        /**
+         * Checks if resource is changed from the most recent snapshot.
+         * @returns {Boolean} true if the latest snapshot differs from resource as-is
+         */
+        function unsnappedChanges() {
+            if (!this.$snapshots) {
+                return true
+            }
+
+            var copy = this._prepSnapshot(),
+                latestSnap = this.$snapshots[this.$snapshots.length - 1]
+
+            return !angular.equals(copy, latestSnap)
+        }
+
     }]);
 }());

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

@@ -543,28 +543,36 @@
                         resourceConstructor = config.resourceConstructor,
                         promise = $q.when(httpConfig);
 
-                    promise = this.runInterceptorPhase('beforeRequest', context, promise).then(function (httpConfig) {
-                        httpConfig = resourceConstructor.serialize(httpConfig);
+                    if (!config.skipRequestProcessing) {
 
-                        forEachDependency(config.requestTransformers, function (transformer) {
-                            httpConfig.data = transformer(httpConfig.data, config.resourceConstructor);
+                        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;
                         });
 
-                        return httpConfig;
-                    });
+                        promise = this.runInterceptorPhase('beforeRequestWrapping', context, promise);
 
-                    promise = this.runInterceptorPhase('beforeRequestWrapping', context, promise);
+                        if (config.rootWrapping) {
+                            promise = promise.then(function (httpConfig) {
+                                httpConfig.data = railsRootWrapper.wrap(httpConfig.data, config.resourceConstructor);
+                                return httpConfig;
+                            });
+                        }
 
-                    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);
                         });
-                    }
 
-                    promise = this.runInterceptorPhase('request', context, promise).then(function (httpConfig) {
-                        return $http(httpConfig);
-                    });
+                    } else {
+
+                        promise = $http(httpConfig);
+
+                    }
 
                     promise = this.runInterceptorPhase('beforeResponse', context, promise);
 
@@ -711,10 +719,10 @@
                 };
 
                 angular.forEach(['post', 'put', 'patch'], function (method) {
-                    RailsResource['$' + method] = function (url, data) {
+                    RailsResource['$' + method] = function (url, data, resourceConfigOverrides) {
                         // 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()));
+                        return this.$http(angular.extend({method: method, url: url, data: data}, this.getHttpConfig()), null, resourceConfigOverrides);
                     };
 
                     RailsResource.prototype['$' + method] = function (url) {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: angularjs-rails-resource
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Tommy Odom
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-12 00:00:00.000000000 Z
+date: 2014-06-07 00:00:00.000000000 Z
 dependencies: []
 description: A small AngularJS add-on for integrating with Rails via JSON more easily.
 email:
@@ -19,8 +19,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - CHANGELOG.md
 - EXAMPLES.md
 - Gemfile
@@ -71,17 +71,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.9
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: AngularJS add-on resource add-on for integrating with Rails