angularjs-rails-resource 0.0.2

data/test/unit/helpers/spec_helper.js

@@ -0,0 +1,14 @@
+beforeEach(function () {
+    this.addMatchers({
+        toEqualData: function (expected) {
+            return angular.equals(this.actual, expected);
+        },
+        toBeFunction: function () {
+            return angular.isFunction(this.actual);
+        },
+        toBeInstanceOf: function (expected) {
+            return this.actual instanceof expected;
+        }
+
+    });
+});

data/testacular.conf.js

@@ -0,0 +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'
+};

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

@@ -0,0 +1,228 @@
+(function (undefined) {
+    angular.module('rails', ['ng']);
+
+    function transformObject(data, transform) {
+        var newKey;
+
+        if (data && angular.isObject(data)) {
+            angular.forEach(data, function (value, key) {
+                newKey = transform(key);
+
+                if (newKey !== key) {
+                    data[newKey] = value;
+                    delete data[key];
+                }
+
+                transformObject(value, transform);
+            });
+        }
+    }
+
+    function camelize(key) {
+        if (!angular.isString(key)) {
+            return key;
+        }
+
+        // should this match more than word and digit characters?
+        return key.replace(/_[\w\d]/g, function (match, index, string) {
+            return index === 0 ? match : string.charAt(index + 1).toUpperCase();
+        });
+    }
+
+    function underscore(key) {
+        if (!angular.isString(key)) {
+            return key;
+        }
+
+        return key.replace(/[A-Z]/g, function (match, index) {
+            return index === 0 ? match : '_' + match.toLowerCase();
+        });
+    }
+
+    angular.module('rails').factory('railsFieldRenamingTransformer', function () {
+
+        return function (data) {
+            transformObject(data, underscore);
+            return data;
+        };
+    });
+
+    angular.module('rails').factory('railsFieldRenamingInterceptor', function () {
+        return function (promise) {
+            return promise.then(function (response) {
+                transformObject(response.data, camelize);
+                return response;
+            });
+        };
+    });
+
+    angular.module('rails').factory('railsRootWrappingTransformer', function () {
+        return function (data, resource) {
+            var result = {};
+            result[angular.isArray(data) ? resource.rootPluralName : resource.rootName] = data;
+            return result;
+        };
+    });
+
+    angular.module('rails').factory('railsRootWrappingInterceptor', function () {
+        return function (promise) {
+            var resource = promise.resource;
+
+            if (!resource) {
+                return promise;
+            }
+
+            return promise.then(function (response) {
+                if (response.data && response.data.hasOwnProperty(resource.rootName)) {
+                    response.data = response.data[resource.rootName];
+                } else if (response.data && response.data.hasOwnProperty(resource.rootPluralName)) {
+                    response.data = response.data[resource.rootPluralName];
+                }
+
+                return response;
+            });
+        };
+    });
+
+    angular.module('rails').factory('railsResourceFactory', ['$http', '$q', '$injector', function ($http, $q, $injector) {
+
+        function railsResourceFactory(config) {
+            var transformers = config.requestTransformers || ['railsRootWrappingTransformer', 'railsFieldRenamingTransformer'],
+                interceptors = config.responseInterceptors || ['railsFieldRenamingInterceptor', 'railsRootWrappingInterceptor'];
+
+            function RailsResource(value) {
+                angular.extend(this, value || {});
+            }
+
+            RailsResource.url = config.url;
+            RailsResource.rootName = config.name;
+            RailsResource.rootPluralName = config.pluralName || config.name + 's';
+            RailsResource.httpConfig = config.httpConfig || {};
+            RailsResource.requestTransformers = [];
+            RailsResource.responseInterceptors = [];
+            RailsResource.defaultParams = config.defaultParams;
+
+            // copied from $HttpProvider to support interceptors being dependency names or anonymous factory functions
+            angular.forEach(interceptors, function (interceptor) {
+                RailsResource.responseInterceptors.push(
+                    angular.isString(interceptor)
+                        ? $injector.get(interceptor)
+                        : $injector.invoke(interceptor)
+                );
+            });
+
+            angular.forEach(transformers, function (transformer) {
+                RailsResource.requestTransformers.push(
+                    angular.isString(transformer)
+                        ? $injector.get(transformer)
+                        : $injector.invoke(transformer)
+                );
+            });
+
+            RailsResource.transformData = function (data) {
+                angular.forEach(RailsResource.requestTransformers, function (transformer) {
+                    data = transformer(data, RailsResource);
+                });
+
+                return data;
+            };
+
+            RailsResource.callInterceptors = function (promise) {
+
+                angular.forEach(RailsResource.responseInterceptors, function (interceptor) {
+                    promise.resource = RailsResource;
+                    promise = interceptor(promise);
+                });
+
+                return promise;
+            };
+
+            RailsResource.processResponse = function (promise) {
+                promise = RailsResource.callInterceptors(promise);
+
+                return promise.then(function (response) {
+                    var result;
+
+                    if (angular.isArray(response.data)) {
+                        result = [];
+
+                        angular.forEach(response.data, function (value) {
+                            result.push(new RailsResource(value));
+                        });
+                    } else if (angular.isObject(response.data)) {
+                        result = new RailsResource(response.data);
+                    } else {
+                        result = response.data;
+                    }
+
+                    return result;
+                });
+            };
+
+            RailsResource.getHttpConfig = function (queryParams) {
+                var config = angular.copy(RailsResource.httpConfig, {});
+
+                if (RailsResource.defaultParams) {
+                    config.params = RailsResource.defaultParams;
+                }
+
+                if (queryParams) {
+                    config.params = angular.extend(config.params || {}, queryParams);
+                }
+
+                return config;
+            };
+
+            RailsResource.resourceUrl = function (id) {
+                return RailsResource.url + '/' + id;
+            };
+
+            RailsResource.query = function (queryParams) {
+                return RailsResource.processResponse($http.get(RailsResource.url, RailsResource.getHttpConfig(queryParams)));
+            };
+
+            RailsResource.get = function (id) {
+                return RailsResource.processResponse($http.get(RailsResource.resourceUrl(id), RailsResource.getHttpConfig()));
+            };
+
+            RailsResource.prototype.processResponse = function (promise) {
+                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;
+                    return response;
+                });
+
+                promise = RailsResource.callInterceptors(promise);
+
+                return 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);
+                    }
+
+                    return this;
+                }));
+            };
+
+            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()));
+            };
+
+            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()));
+            };
+
+            RailsResource.prototype.remove = RailsResource.prototype.delete = function (id) {
+                return this.processResponse($http.delete(RailsResource.resourceUrl(this.id), RailsResource.getHttpConfig()));
+            };
+
+            return RailsResource;
+        }
+
+        return railsResourceFactory;
+    }]);
+}());

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: angularjs-rails-resource
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Tommy Odom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-01 00:00:00.000000000 Z
+dependencies: []
+description: A small AngularJS add-on for integrating with Rails via JSON more easily.
+email:
+- odom@finelineprototyping.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- angularjs-rails-resource.gemspec
+- lib/angularjs-rails-resource.rb
+- lib/angularjs-rails-resource/version.rb
+- test/lib/angular/angular-bootstrap-prettify.js
+- test/lib/angular/angular-bootstrap.js
+- test/lib/angular/angular-cookies.js
+- test/lib/angular/angular-loader.js
+- test/lib/angular/angular-mocks.js
+- test/lib/angular/angular-resource.js
+- test/lib/angular/angular-sanitize.js
+- test/lib/angular/angular.js
+- test/unit/angularjs/rails/resourceSpec.js
+- test/unit/helpers/spec_helper.js
+- testacular.conf.js
+- vendor/assets/javascripts/angularjs/rails/resource.js
+homepage: https://github.com/tpodom/angularjs-rails-resource
+licenses: []
+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.24
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- test/lib/angular/angular-bootstrap-prettify.js
+- test/lib/angular/angular-bootstrap.js
+- test/lib/angular/angular-cookies.js
+- test/lib/angular/angular-loader.js
+- test/lib/angular/angular-mocks.js
+- test/lib/angular/angular-resource.js
+- test/lib/angular/angular-sanitize.js
+- test/lib/angular/angular.js
+- test/unit/angularjs/rails/resourceSpec.js
+- test/unit/helpers/spec_helper.js