angularjs-rails-resource 0.0.2 → 0.1.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Tommy Odom
+Copyright (c) 2012 - 2013 FineLine Prototyping, Inc.
 
 MIT License
 

data/README.md

@@ -6,8 +6,17 @@ When starting out with AngularJS and Rails we initially were using $resource but
 
  1.  $resource didn't return promises
  2.  Rails prefers JSON be root wrapped
- 3.  Our JSON contained snake case keys coming from our database but we didn't want to mix snake case and camel case in our UI
+ 3.  Our JSON contained snake case (underscored) keys coming from our database but we didn't want to mix snake case and camel case in our UI
 
+In case you are unfamiliar, the intent of the resource is to behave a bit like a remote model object.  One of the nice things about AngularJS
+ is that it does not require you to create specific models for all of your data which gives you a lot of freedom for treating model data as basic
+ javascript objects.  However, on the Rails side when exposing models to a javascript application you are likely going to follow the same pattern for multiple
+ models where you will have a controller that has your basic index (query), get, create, update, delete functionality.
+
+The resource object created by this factory simplifies access to those models by exposing a mix of "class" methods (query, get) and
+ "instance" methods (create, update, delete/remove).
+
+This module is being used for applications we are writing and we expect that over time that we will be adding additional functionality but we welcome contributions and suggestions.
 
 ## Installation
 
@@ -26,16 +35,22 @@ Since this is an [AngularJS](http://angularjs.org) module it of course depends o
 * [$http](http://docs.angularjs.org/api/ng.$http)
 * [$q](http://docs.angularjs.org/api/ng.$q)
 * [$injector](http://docs.angularjs.org/api/AUTO.$injector)
+* [$interpolate](http://docs.angularjs.org/api/ng.$interpolate)
 
 ## Resource Creation
-Creating a resource using this factory is similar to using $resource, you just call the factory with the config options and get back your resource.
+Creating a resource using this factory is similar to using $resource, you just call the factory with the config options and it returns a new resource function.
+The resource function serves two purposes.  First is that you can use (or define new) "class" methods directly accessible such as query and get to retrieve
+instances from the backend rails service.  The second is that it allows you to use it as a constructor to create new instances of that resource giving you access
+to create, update, and delete instance methods (or any others you add).
+
+The typical use case is to define the resource as an AngularJS factory within a module and then inject that into a controller or directive.
+See [Examples](#examples) below for more information on creating and injecting the resource.
 
-    var resource = railsResourceFactory(config);
 
 ### Config Options
 The following options are available for the config object passed to the factory function.
 
- * **url** - This is the base url of the service.  See [Resource URLs](#resource-urls) below for more information.
+ * **url** - This is the url of the service.  See [Resource URLs](#resource-urls) below for more information.
  * **name** - This is the name used for root wrapping when dealing with singular instances.
  * **pluralName** *(optional)* - If specified this name will be used for unwrapping query results,
         if not specified the singular name with an appended 's' will be used.
@@ -48,8 +63,20 @@ The following options are available for the config object passed to the factory
 For example, you should specify "publishingCompany" and "publishingCompanies" instead of "publishing_company" and "publishing_companies".
 
 ## Resource URLs
-The resource url functionality is pretty basic right now.  The base url is used for query and create and the resource url
-is assumed to be the base url followed by the id.  Therefore, a base url of '/books' will result in a resource url of '/books/123'.
+The URL can be specified as one of three ways:
+
+ 1. function (context) - You can pass your own custom function that converts a context variable into a url string
+
+ 2. basic string - A string without any expression variables will be treated as a base URL and assumed that instance requests should append id to the end.
+
+ 3. AngularJS expression - An expression url is evaluated at run time based on the given context for non-instance methods or the instance itself. For example, given the url expression: /stores/{{storeId}}/items/{{id}}
+
+        Item.query({category: 'Software'}, {storeId: 123}) would generate a GET to /stores/1234/items?category=Software
+        Item.get({storeId: 123, id: 1}) would generate a GET to /stores/123/items/1
+
+        new Item({store: 123}).create() would generate a POST to /stores/123/items
+        new Item({id: 1, storeId: 123}).update() would generate a PUT to /stores/123/items/1
+
 
 ## Transformers / Interceptors
 The transformers and interceptors can be specified using an array containing transformer/interceptor functions or strings
@@ -93,7 +120,7 @@ Resources created using this factory have the following methods available and ea
 ### constructor
 ***
 
-The constructor function is to create new instances of the resource.
+The constructor is the function returned by the railsResourceFactory and can be used with the "new" keyword.
 
 ####Parameters
  * **data** *(optional)* - An object containing the data to be stored in the instance.
@@ -104,7 +131,8 @@ The constructor function is to create new instances of the resource.
 A "class" method that executes a GET request against the base url with query parameters set via the params option.
 
 ####Parameters
- * **params** - An map of strings or objects that are passed to $http to be turned into query parameters
+ * **query params** - An map of strings or objects that are passed to $http to be turned into query parameters
+ * **context** - A context object that is used during url evaluation to resolve expression variables
 
 
 ### get
@@ -113,7 +141,7 @@ A "class" method that executes a GET request against the base url with query par
 A "class" method that executes a GET request against the resource url.
 
 ####Parameters
- * **id** - The id of the resource to retrieve
+ * **context** - A context object that is used during url evaluation to resolve expression variables.  If you are using a basic url this can be an id number to append to the url.
 
 
 ### create
@@ -147,32 +175,26 @@ None
 
 
 ## Example
-Creating a Book resource would look something like:
+For a complete working example (including the rails side), check out the [Employee Training Tracker](https://github.com/FineLinePrototyping/employee-training-tracker) application
+we open sourced based on an interface we created for use internally that uses this module as well as many others.
+
+### Define Resource
+In order to create a Book resource, we would first define the factory within a module.
 
     angular.module('book.services', ['rails']);
     angular.module('book.services').factory('Book', ['railsResourceFactory', function (railsResourceFactory) {
         return railsResourceFactory({url: '/books', name: 'book'});
     }]);
 
-#### Query Books
-    var books = Book.query({title: 'The Hobbit'});
+We would then inject that service into a controller:
 
-#### Get Book
-    var book = Book.get(1234);
-
-#### Create Book
-    var book = new Book({author: 'J. R. R. Tolkein', title: 'The Hobbit'});
-    book.create().then(function (result) {
-        // creation was successful
-    });
+    angular.module('book.controllers').controller('BookShelfCtrl', ['$scope', 'Book', function ($scope, Book) {
+        // See following examples for using Book within your controller
+    }]);
 
-#### Update Book
-    Book.get(1234).then(function (book) {
-        book.author = 'J. R. R. Tolkein';
-        book.update();
-    });
+The examples below illustrate how you would then use the Book service to get, create, update, and delete data.
 
-## Extending
+#### Extending
 You can add additional "class" or "instance" methods by modifying the resource returned from the factory call.  For instance,
 if you wanted to add a "class" method named "findByTitle" to the Book resource you would modify the service setup as follows:
 
@@ -182,18 +204,81 @@ if you wanted to add a "class" method named "findByTitle" to the Book resource y
         resource.findByTitle = function (title) {
             return resource.query({title: title});
         };
+        return resource;
     }]);
 
-If you wanted to add an "instance" method (I couldn't come up with an example for this) you would add a new function to the resource prototype object:
+If you wanted to add an "instance" method to retrieve a related object:
 
     angular.module('book.services', ['rails']);
-    angular.module('book.services').factory('Book', ['railsResourceFactory', function (railsResourceFactory) {
+    angular.module('book.services').factory('Author', ['railsResourceFactory', function (railsResourceFactory) {
+        return railsResourceFactory({url: '/authors', name: 'author'});
+    }]);
+    angular.module('book.services').factory('Book', ['railsResourceFactory', 'Author', function (railsResourceFactory, Author) {
+        var resource = railsResourceFactory({url: '/books', name: 'book'});
+        resource.prototype.getAuthor = function () {
+            return Author.get(this.authorId);
+        };
+    }]);
+
+Or say you instead had a nested "references" service call that returned a list of referenced books for a given book instance.  In that case you can add your own addition method that calls $http.get and then
+passes the resulting promise to the processResponse method which will perform the same transformations and handling that the get or query would use.
+
+    angular.module('book.services', ['rails']);
+    angular.module('book.services').factory('Book', ['railsResourceFactory', '$http', function (railsResourceFactory, $http) {
         var resource = railsResourceFactory({url: '/books', name: 'book'});
-        resource.prototype.doSomething = function () {
-            // do something here
+        resource.prototype.getReferences = function () {
+            var self = this;
+            return resource.processResponse($http.get(resource.resourceUrl(this.id) + '/references')).then(function (references) {
+                self.references = references;
+                return self.references;
+            });
         };
     }]);
 
+### Query Books
+To query for a list of books with the title "The Hobbit" you would use the query method:
+
+    var books = Book.query({title: 'The Hobbit'});
+
+We now have a promise in the books variable which we could then use within a template if we just wanted to do an ng-repeat over the books.  A lot of times though you'll probably want to show some indicator
+to your user that the search is executing so you'd want to use a then handler:
+
+    $scope.searching = true;
+    var books = Book.query({title: 'The Hobbit'});
+    books.then(function(results) {
+        $scope.searching = false;
+    }, function (error) {
+        $scope.searching = false;
+        // display error
+    });
+
+
+### Get Book
+    var book = Book.get(1234);
+
+Again, it's important to remember that book is a promise, if instead you wanted the book data you would use the "then" function:
+
+    Book.get(1234).then(function (book) {
+       // book contains the data returned from the service
+    });
+
+### Create Book
+    var book = new Book({author: 'J. R. R. Tolkein', title: 'The Hobbit'});
+    book.create().then(function (result) {
+        // creation was successful
+    });
+
+### Update Book
+    Book.get(1234).then(function (book) {
+        book.author = 'J. R. R. Tolkein';
+        book.update();
+    });
+
+Or, if you say the user typed in the book id into a scope variable and you wanted to update the book without having to first retrieve it:
+
+    var book = new Book({id: $scope.bookId, author: $scope.authorName, title: $scope.bookTitle});
+    book.update();
+
 ## Tests
 The tests are written using [Jasmine](http://pivotal.github.com/jasmine/) and are run using [Testacular](http://vojtajina.github.com/testacular/).
 

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

@@ -1,7 +1,7 @@
 module Angularjs
   module Rails
     module Resource
-      VERSION = "0.0.2"
+      VERSION = "0.1.0"
     end
   end
 end

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

@@ -134,15 +134,11 @@ describe("js.rails", function () {
         });
     });
 
-    describe('railsResourceFactory', function() {
-        var $httpBackend, $rootScope, factory, Test, PluralTest,
+    describe('singular railsResourceFactory', function() {
+        var $httpBackend, $rootScope, factory, Test,
             config = {
                 url: '/test',
                 name: 'test'
-            }, pluralConfig = {
-                url: '/pluralTest',
-                name: 'singular',
-                pluralName: 'plural'
             };
 
         beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory) {
@@ -150,7 +146,6 @@ describe("js.rails", function () {
             $rootScope = _$rootScope_;
             factory = railsResourceFactory;
             Test = railsResourceFactory(config);
-            PluralTest = railsResourceFactory(pluralConfig);
         }));
 
         afterEach(function() {
@@ -222,34 +217,12 @@ describe("js.rails", function () {
             $httpBackend.flush();
         }));
 
-        it('query should return array of resource objects when result is an array', inject(function($httpBackend) {
-            var promise, result;
-
-            $httpBackend.expectGET('/pluralTest').respond(200, {plural: [{abc: 'xyz'}, {xyz: 'abc'}]});
-
-            expect(promise = PluralTest.query()).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(angular.isArray(result)).toBe(true);
-            angular.forEach(result, function (value) {
-                expect(value).toBeInstanceOf(PluralTest);
-            });
-            expect(result[0]).toEqualData({abc: 'xyz'});
-            expect(result[1]).toEqualData({xyz: 'abc'});
-
-        }));
-
-        it('query should return empty array when result is empty array', inject(function($httpBackend) {
+        it('get should return resource object when response is 200', inject(function($httpBackend) {
             var promise, result;
 
-            $httpBackend.expectGET('/pluralTest').respond(200, {plural: []});
+            $httpBackend.expectGET('/test/123').respond(200, {test: {id: 123, abc: 'xyz'}});
 
-            expect(promise = PluralTest.query()).toBeDefined();
+            expect(promise = Test.get(123)).toBeDefined();
 
             promise.then(function (response) {
                 result = response;
@@ -257,17 +230,16 @@ describe("js.rails", function () {
 
             $httpBackend.flush();
 
-            expect(angular.isArray(result)).toBe(true);
-            expect(result.length).toBe(0);
+            expect(result).toBeInstanceOf(Test);
+            expect(result).toEqualData({id: 123, abc: 'xyz'});
         }));
 
-
-        it('get should return resource object when response is 200', inject(function($httpBackend) {
+        it('get should work with id as string as well', inject(function($httpBackend) {
             var promise, result;
 
             $httpBackend.expectGET('/test/123').respond(200, {test: {id: 123, abc: 'xyz'}});
 
-            expect(promise = Test.get(123)).toBeDefined();
+            expect(promise = Test.get('123')).toBeDefined();
 
             promise.then(function (response) {
                 result = response;
@@ -340,7 +312,7 @@ describe("js.rails", function () {
             angular.copy(config, testConfig);
             testConfig.requestTransformers = [];
             testConfig.responseInterceptors = ['railsFieldRenamingInterceptor'];
-            resource = factory(config);
+            resource = factory(testConfig);
 
             expect(promise = resource.get(123)).toBeDefined();
 
@@ -483,4 +455,372 @@ describe("js.rails", function () {
         }));
     });
 
+    describe('plural railsResourceFactory', function() {
+        var $httpBackend, $rootScope, factory, PluralTest,
+            pluralConfig = {
+                url: '/pluralTest',
+                name: 'singular',
+                pluralName: 'plural'
+            };
+
+        beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory) {
+            $httpBackend = _$httpBackend_;
+            $rootScope = _$rootScope_;
+            factory = railsResourceFactory;
+            PluralTest = railsResourceFactory(pluralConfig);
+        }));
+
+        afterEach(function() {
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        it('query should return array of resource objects when result is an array', inject(function($httpBackend) {
+            var promise, result;
+
+            $httpBackend.expectGET('/pluralTest').respond(200, {plural: [{abc: 'xyz'}, {xyz: 'abc'}]});
+
+            expect(promise = PluralTest.query()).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(angular.isArray(result)).toBe(true);
+            angular.forEach(result, function (value) {
+                expect(value).toBeInstanceOf(PluralTest);
+            });
+            expect(result[0]).toEqualData({abc: 'xyz'});
+            expect(result[1]).toEqualData({xyz: 'abc'});
+
+        }));
+
+        it('query should return empty array when result is empty array', inject(function($httpBackend) {
+            var promise, result;
+
+            $httpBackend.expectGET('/pluralTest').respond(200, {plural: []});
+
+            expect(promise = PluralTest.query()).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(angular.isArray(result)).toBe(true);
+            expect(result.length).toBe(0);
+        }));
+    });
+
+    describe('nested railsResourceFactory', function() {
+        var $httpBackend, $rootScope, factory, NestedTest,
+            nestedConfig = {
+                url: '/nested/{{nestedId}}/test/{{id}}',
+                name: 'nestedTest'
+            };
+
+        beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory) {
+            $httpBackend = _$httpBackend_;
+            $rootScope = _$rootScope_;
+            factory = railsResourceFactory;
+            NestedTest = railsResourceFactory(nestedConfig);
+        }));
+
+        afterEach(function() {
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        it('query should return resource object when response is single object', inject(function($httpBackend) {
+            var promise, result;
+
+            $httpBackend.expectGET('/nested/1234/test').respond(200, {nested_test: {abc: 'xyz'}});
+
+            expect(promise = NestedTest.query(null, {nestedId: 1234})).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(NestedTest);
+            expect(result).toEqualData({abc: 'xyz'});
+        }));
+
+        it('query should return no data on 204', inject(function($httpBackend) {
+            var promise, result;
+
+            $httpBackend.expectGET('/nested/1234/test').respond(204);
+            expect(promise = NestedTest.query(null, {nestedId: 1234})).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeUndefined();
+        }));
+
+        it('query should add parameter abc=1', inject(function($httpBackend) {
+            var promise;
+
+            $httpBackend.expectGET('/nested/1234/test?abc=1').respond(200, {nested_test: {abc: 'xyz'}});
+
+            expect(promise = NestedTest.query({abc: '1'}, {nestedId: 1234})).toBeDefined();
+            $httpBackend.flush();
+        }));
+
+        it('query should add parameters abc=1 & xyz=2', inject(function($httpBackend) {
+            var promise;
+
+            $httpBackend.expectGET('/nested/1234/test?abc=1&xyz=2').respond(200, {nested_test: {abc: 'xyz'}});
+
+            expect(promise = NestedTest.query({abc: '1', xyz: 2}, {nestedId: 1234})).toBeDefined();
+            $httpBackend.flush();
+        }));
+
+        it('query with default params should add parameter abc=1', inject(function($httpBackend) {
+            var promise, resource, defaultParamsConfig = {};
+
+            $httpBackend.expectGET('/nested/1234/test?abc=1').respond(200, {nested_test: {abc: 'xyz'}});
+
+            angular.copy(nestedConfig, defaultParamsConfig);
+            defaultParamsConfig.defaultParams = {abc: '1'};
+
+            resource = factory(defaultParamsConfig);
+            expect(promise = resource.query(null, {nestedId: 1234})).toBeDefined();
+
+            $httpBackend.flush();
+        }));
+
+        it('get should return resource object when response is 200', inject(function($httpBackend) {
+            var promise, result;
+
+            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {nested_test: {id: 123, abc: 'xyz'}});
+
+            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(NestedTest);
+            expect(result).toEqualData({id: 123, abc: 'xyz'});
+        }));
+
+        it('get should call failure callback when 404', inject(function($httpBackend) {
+            var promise, success = false, failure = false;
+
+            $httpBackend.expectGET('/nested/1234/test/123').respond(404);
+
+            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
+
+            promise.then(function () {
+                success = true;
+            }, function () {
+                failure = true;
+            });
+
+            $httpBackend.flush();
+
+            expect(success).toBe(false);
+            expect(failure).toBe(true);
+        }));
+
+        it('get with default params should add parameter abc=1', inject(function($httpBackend) {
+            var promise, resource, defaultParamsConfig = {};
+
+            $httpBackend.expectGET('/nested/1234/test/123?abc=1').respond(200, {nested_test: {abc: 'xyz'}});
+
+            angular.copy(nestedConfig, defaultParamsConfig);
+            defaultParamsConfig.defaultParams = {abc: '1'};
+
+            resource = factory(defaultParamsConfig);
+            expect(promise = resource.get({nestedId: 1234, id: 123})).toBeDefined();
+
+            $httpBackend.flush();
+        }));
+
+        it('should be able to turn off root mapping and field renaming', inject(function($httpBackend) {
+            var promise, result, resource;
+
+            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {id: 123, nested_id: 1234, abc_def: 'xyz'});
+
+            resource = factory(nestedConfig);
+            resource.responseInterceptors = [];
+            resource.requestTransformers = [];
+            expect(promise = resource.get({nestedId: 1234, id: 123})).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(resource);
+            expect(result).toEqualData({id: 123, nested_id: 1234, abc_def: 'xyz'});
+        }));
+
+        it('should be able to turn off root mapping but keep field renaming', inject(function($httpBackend) {
+            var promise, result, resource, testConfig = {};
+
+            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {id: 123, nested_id: 1234, abc_def: 'xyz'});
+
+            angular.copy(nestedConfig, testConfig);
+            testConfig.requestTransformers = [];
+            testConfig.responseInterceptors = ['railsFieldRenamingInterceptor'];
+            resource = factory(testConfig);
+
+            expect(promise = resource.get({nestedId: 1234, id: 123})).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(resource);
+            expect(result).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz'});
+        }));
+
+        it('should be able to create new instance and save it', inject(function($httpBackend) {
+            var data = new NestedTest({nestedId: 1234, abcDef: 'xyz'});
+
+            $httpBackend.expectPOST('/nested/1234/test').respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz'}});
+            data.nestedId = 1234;
+            data.create();
+            $httpBackend.flush();
+
+            expect(data).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz'});
+        }));
+
+        it('should be able to create new instance and update it', inject(function($httpBackend) {
+            var data = new NestedTest({abcDef: 'xyz'});
+
+            $httpBackend.expectPOST('/nested/1234/test').respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz'}});
+            data.nestedId = 1234;
+            data.create();
+            $httpBackend.flush(1);
+
+            expect(data).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz'});
+
+            $httpBackend.expectPUT('/nested/1234/test/123').respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz', xyz: 'abc', extra: 'test'}});
+            data.xyz = 'abc';
+            data.update();
+            $httpBackend.flush();
+
+            expect(data).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz', xyz: 'abc', extra: 'test'});
+        }));
+
+        it('create with default params should add parameter abc=1', inject(function($httpBackend) {
+            var promise, Resource, data, defaultParamsConfig = {};
+
+            $httpBackend.expectPOST('/nested/1234/test?abc=1').respond(200, {nested_test: {abc: 'xyz'}});
+
+            angular.copy(nestedConfig, defaultParamsConfig);
+            defaultParamsConfig.defaultParams = {abc: '1'};
+
+            Resource = factory(defaultParamsConfig);
+            data = new Resource();
+            data.nestedId = 1234;
+            data.create();
+
+            $httpBackend.flush();
+        }));
+
+        it('should be able to get resource and update it', inject(function($httpBackend) {
+            var promise, result;
+
+            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {nested_test: {id: 123, nested_id: 1234, abc: 'xyz'}});
+
+            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(NestedTest);
+            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz'});
+
+            $httpBackend.expectPUT('/nested/1234/test/123').respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz', xyz: 'abc', extra: 'test'}});
+            result.xyz = 'abc';
+            result.update();
+            $httpBackend.flush();
+
+            // abc was originally set on the object so it should still be there after the update
+            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz', abcDef: 'xyz', xyz: 'abc', extra: 'test'});
+        }));
+
+        it('update should handle 204 response', inject(function($httpBackend) {
+            var promise, result;
+
+            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {nested_test: {id: 123, nested_id: 1234, abc: 'xyz'}});
+
+            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(NestedTest);
+            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz'});
+
+            $httpBackend.expectPUT('/nested/1234/test/123').respond(204);
+            result.xyz = 'abc';
+            result.update();
+            $httpBackend.flush();
+
+            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz', xyz: 'abc'});
+        }));
+
+        it('should be able to delete instance returned from get', inject(function($httpBackend) {
+            var promise, result;
+
+            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {nested_test: {id: 123, nestedId: 1234, abc: 'xyz'}});
+
+            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(NestedTest);
+            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz'});
+
+            $httpBackend.expectDELETE('/nested/1234/test/123').respond(204);
+            result.remove();
+            $httpBackend.flush();
+        }));
+
+        it('delete with default params should add parameter abc=1', inject(function($httpBackend) {
+            var Resource, data, defaultParamsConfig = {};
+
+            $httpBackend.expectDELETE('/nested/1234/test/123?abc=1').respond(204);
+
+            angular.copy(nestedConfig, defaultParamsConfig);
+            defaultParamsConfig.defaultParams = {abc: '1'};
+
+            Resource = factory(defaultParamsConfig);
+            data = new Resource();
+            data.id = 123;
+            data.nestedId = 1234;
+            data.remove();
+
+            $httpBackend.flush();
+        }));
+    });
+
 });

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

@@ -84,7 +84,30 @@
         };
     });
 
-    angular.module('rails').factory('railsResourceFactory', ['$http', '$q', '$injector', function ($http, $q, $injector) {
+    angular.module('rails').factory('railsResourceFactory', ['$http', '$q', '$injector', '$interpolate', function ($http, $q, $injector, $interpolate) {
+        function urlBuilder(url) {
+            var expression;
+
+            if (angular.isFunction(url)) {
+                return url;
+            }
+
+            if (url.indexOf('{{') === -1) {
+                url = url + '/{{id}}';
+            }
+
+            expression = $interpolate(url);
+
+            return function (params) {
+                url = expression(params);
+
+                if (url.charAt(url.length - 1) === '/') {
+                    url = url.substr(0, url.length - 1);
+                }
+
+                return url;
+            };
+        }
 
         function railsResourceFactory(config) {
             var transformers = config.requestTransformers || ['railsRootWrappingTransformer', 'railsFieldRenamingTransformer'],
@@ -94,7 +117,7 @@
                 angular.extend(this, value || {});
             }
 
-            RailsResource.url = config.url;
+            RailsResource.url = urlBuilder(config.url);
             RailsResource.rootName = config.name;
             RailsResource.rootPluralName = config.pluralName || config.name + 's';
             RailsResource.httpConfig = config.httpConfig || {};
@@ -159,30 +182,58 @@
                 });
             };
 
-            RailsResource.getHttpConfig = function (queryParams) {
-                var config = angular.copy(RailsResource.httpConfig, {});
+            RailsResource.getParameters = function (queryParams) {
+                var params;
 
                 if (RailsResource.defaultParams) {
-                    config.params = RailsResource.defaultParams;
+                    params = RailsResource.defaultParams;
                 }
 
-                if (queryParams) {
-                    config.params = angular.extend(config.params || {}, queryParams);
+                if (angular.isObject(queryParams)) {
+                    params = angular.extend(params || {}, queryParams);
+                }
+
+                return params;
+            };
+
+            RailsResource.getHttpConfig = function (queryParams) {
+                var params = RailsResource.getParameters(queryParams);
+
+                if (params) {
+                    return angular.extend({params: params}, RailsResource.httpConfig);
                 }
 
-                return config;
+                return RailsResource.httpConfig;
             };
 
-            RailsResource.resourceUrl = function (id) {
-                return RailsResource.url + '/' + id;
+            /**
+             * Returns a URL from the given parameters.  You can override this method on your resource definitions to provide
+             * custom logic for building your URLs or you can utilize the parameterized url strings to substitute values in the
+             * URL string.
+             *
+             * The parameters in the URL string follow the normal Angular binding expression using {{ and }} for the start/end symbols.
+             *
+             * If the context is a number and the URL string does not contain an id parameter then the number is appended
+             * to the URL string.
+             *
+             * If the context is a number and the URL string does
+             * @param context
+             * @return {string}
+             */
+            RailsResource.resourceUrl = function (context) {
+                if (!angular.isObject(context)) {
+                    context = {id: context};
+                }
+
+                return RailsResource.url(context || {});
             };
 
-            RailsResource.query = function (queryParams) {
-                return RailsResource.processResponse($http.get(RailsResource.url, RailsResource.getHttpConfig(queryParams)));
+            RailsResource.query = function (queryParams, context) {
+                return RailsResource.processResponse($http.get(RailsResource.resourceUrl(context), RailsResource.getHttpConfig(queryParams)));
             };
 
-            RailsResource.get = function (id) {
-                return RailsResource.processResponse($http.get(RailsResource.resourceUrl(id), RailsResource.getHttpConfig()));
+            RailsResource.get = function (context, queryParams) {
+                return RailsResource.processResponse($http.get(RailsResource.resourceUrl(context), RailsResource.getHttpConfig(queryParams)));
             };
 
             RailsResource.prototype.processResponse = function (promise) {
@@ -207,17 +258,17 @@
             RailsResource.prototype.create = function () {
                 // clone so we can manipulate w/o modifying our instance
                 var data = RailsResource.transformData(angular.copy(this, {}));
-                return this.processResponse($http.post(RailsResource.url, data, RailsResource.getHttpConfig()));
+                return this.processResponse($http.post(RailsResource.resourceUrl(this), data, RailsResource.getHttpConfig()));
             };
 
             RailsResource.prototype.update = function () {
                 // clone so we can manipulate w/o modifying our instance
                 var data = RailsResource.transformData(angular.copy(this, {}));
-                return this.processResponse($http.put(RailsResource.resourceUrl(this.id), data, RailsResource.getHttpConfig()));
+                return this.processResponse($http.put(RailsResource.resourceUrl(this), data, RailsResource.getHttpConfig()));
             };
 
-            RailsResource.prototype.remove = RailsResource.prototype.delete = function (id) {
-                return this.processResponse($http.delete(RailsResource.resourceUrl(this.id), RailsResource.getHttpConfig()));
+            RailsResource.prototype.remove = RailsResource.prototype.delete = function () {
+                return this.processResponse($http.delete(RailsResource.resourceUrl(this), RailsResource.getHttpConfig()));
             };
 
             return RailsResource;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: angularjs-rails-resource
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-01 00:00:00.000000000 Z
+date: 2013-02-11 00:00:00.000000000 Z
 dependencies: []
 description: A small AngularJS add-on for integrating with Rails via JSON more easily.
 email: