use grunt-bump to handle auto-upating package.json and bower.json, automatically insert package.json's versio information into the source file to register the version with Ember.libraries.register

shuffle grunt configs to allow a "grunt release" version bump command to use the new version directly instead of the git tag because the tag won't have been committed yet meaning the source would be marked with the wrong version.

create a build/ folder only during version bumps.

add v1.0.0 built files to build/ and point bower.json to the new location

Author: craigteegarden

Gruntfile.js

@@ -2,8 +2,9 @@ module.exports = function (grunt) {
 
     require('load-grunt-config')(grunt);
 
-    grunt.task.registerTask('test', ['build', 'jshint', 'emberhandlebars', 'concat:test', 'karma']);
-    grunt.task.registerTask('build', ['neuter:build']);
-    grunt.task.registerTask('dist', ['build', 'replace:strip_debug_messages_production', 'uglify:dist', 'get_git_rev', 'usebanner']);
-    grunt.task.registerTask('default', ['dist']);
+    grunt.task.registerTask('release', ['bump-only', 'dist', 'usebanner:bump', 'copy:bump', 'bump-commit']);
+    grunt.task.registerTask('test', ['dist', 'usebanner:distBanner', 'jshint', 'emberhandlebars', 'concat:test', 'karma']);
+    grunt.task.registerTask('build', ['neuter:build', 'replace:update_version']);
+    grunt.task.registerTask('dist', ['build', 'replace:strip_debug_messages_production', 'uglify:dist', 'get_git_rev']);
+    grunt.task.registerTask('default', ['dist', 'usebanner:distBanner']);
 }

README.md

@@ -14,8 +14,7 @@
     <script type="text/javascript" src="/bower_components/handlebars/handlebars.js"></script>
     <script type="text/javascript" src="/bower_components/ember/ember.js"></script>
     <script type="text/javascript" src="/bower_components/ember-data/ember-data.js"></script>
-    <script type="text/javascript" src="/bower_components/ember-data-django-rest-adapter/src/serializer.js"></script>
-    <script type="text/javascript" src="/bower_components/ember-data-django-rest-adapter/src/adapter.js"></script>
+    <script type="text/javascript" src="/bower_components/ember-data-django-rest-adapter/build/ember-data-django-rest-adapter.js"></script>
 
 ## Motivation
 - The `django-rest-framework` is a great REST framework for python / django developers

VERSION

@@ -6,7 +6,7 @@
     "Toran Billups <toranb@gmail.com>"
   ],
   "description": "An ember-data adapter for django web applications powered by the django-rest-framework",
-  "main": "src/main.js",
+  "main": "build/ember-data-django-rest-adapter.js",
   "dependencies": {
       "ember": "~1.4.0",
       "ember-data": "~1.0.0-beta.5"

bower.json

@@ -0,0 +1,304 @@
+// ==========================================================================
+// Project:   Ember Data Django Rest Adapter
+// Copyright: (c) 2013 Toran Billups http://toranbillups.com
+// License:   MIT
+// ==========================================================================
+
+
+// v1.0.0
+// d45d071 (2014-01-08 21:19:17 -0600)
+
+
+(function() {
+
+DS.DjangoRESTSerializer = DS.RESTSerializer.extend({
+
+    init: function() {
+        this._super.apply(this, arguments);
+    },
+
+    extractDjangoPayload: function(store, type, payload) {
+        type.eachRelationship(function(key, relationship){
+            if (!Ember.isNone(payload[key]) &&
+                typeof(payload[key][0]) !== 'number' &&
+                typeof(payload[key][0]) !== 'string' &&
+                relationship.kind ==='hasMany') {
+              if (Ember.typeOf(payload[key]) === 'array' && payload[key].length > 0) {
+                var ids = payload[key].mapBy('id'); //todo find pk (not always id)
+                this.pushArrayPayload(store, relationship.type, payload[key]);
+                payload[key] = ids;
+              }
+            }
+            else if (!Ember.isNone(payload[key]) && typeof(payload[key]) === 'object' && relationship.kind ==='belongsTo') {
+                var id=payload[key].id;
+                this.pushSinglePayload(store,relationship.type,payload[key]);
+                payload[key]=id;
+            }
+        }, this);
+    },
+
+    extractSingle: function(store, type, payload) {
+        // using normalize from RESTSerializer applies transforms and allows
+        // us to define keyForAttribute and keyForRelationship to handle
+        // camelization correctly.
+        this.normalize(type, payload);
+        this.extractDjangoPayload(store, type, payload);
+        return payload;
+    },
+
+    extractArray: function(store, type, payload) {
+        var self = this;
+        for (var j = 0; j < payload.length; j++) {
+            // using normalize from RESTSerializer applies transforms and allows
+            // us to define keyForAttribute and keyForRelationship to handle
+            // camelization correctly.
+            this.normalize(type, payload[j]);
+            self.extractDjangoPayload(store, type, payload[j]);
+        }
+        return payload;
+    },
+
+    /**
+      This method allows you to push a single object payload.
+
+      It will first normalize the payload, so you can use this to push
+      in data streaming in from your server structured the same way
+      that fetches and saves are structured.
+
+      @param {DS.Store} store
+      @param {String} type
+      @param {Object} payload
+    */
+    pushSinglePayload: function(store, type, payload) {
+        type = store.modelFor(type);
+        payload = this.extract(store, type, payload, null, "find");
+        store.push(type, payload);
+    },
+
+    /**
+      This method allows you to push an array of object payloads.
+
+      It will first normalize the payload, so you can use this to push
+      in data streaming in from your server structured the same way
+      that fetches and saves are structured.
+
+      @param {DS.Store} store
+      @param {String} type
+      @param {Object} payload
+    */
+    pushArrayPayload: function(store, type, payload) {
+        type = store.modelFor(type);
+        payload = this.extract(store, type, payload, null, "findAll");
+        store.pushMany(type, payload);
+    },
+
+    /**
+      Converts camelcased attributes to underscored when serializing.
+
+      Stolen from DS.ActiveModelSerializer.
+
+      @method keyForAttribute
+      @param {String} attribute
+      @returns String
+    */
+    keyForAttribute: function(attr) {
+        return Ember.String.decamelize(attr);
+    },
+
+    /**
+      Underscores relationship names when serializing relationship keys.
+
+      Stolen from DS.ActiveModelSerializer.
+
+      @method keyForRelationship
+      @param {String} key
+      @param {String} kind
+      @returns String
+    */
+    keyForRelationship: function(key, kind) {
+        return Ember.String.decamelize(key);
+    },
+
+    /**
+      Underscore relationship names when serializing belongsToRelationships
+
+      @method serializeBelongsTo
+    */
+    serializeBelongsTo: function(record, json, relationship) {
+        var key = relationship.key;
+        var belongsTo = record.get(key);
+        var json_key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo") : key;
+
+        if (Ember.isNone(belongsTo)) {
+          json[json_key] = belongsTo;
+        } else {
+          if (typeof(record.get(key)) === 'string') {
+            json[json_key] = record.get(key);
+          }else{
+            json[json_key] = record.get(key).get('id');
+          }
+        }
+
+        if (relationship.options.polymorphic) {
+          this.serializePolymorphicType(record, json, relationship);
+        }
+    },
+
+    /**
+      Underscore relationship names when serializing hasManyRelationships
+
+      @method serializeHasMany
+    */
+    serializeHasMany: function(record, json, relationship) {
+        var key = relationship.key,
+            json_key = this.keyForRelationship(key, "hasMany"),
+            relationshipType = DS.RelationshipChange.determineRelationshipType(
+                record.constructor, relationship);
+
+        if (relationshipType === 'manyToNone' ||
+            relationshipType === 'manyToMany')
+            json[json_key] = record.get(key).mapBy('id');
+    }
+
+});
+
+
+})();
+
+(function() {
+
+var get = Ember.get;
+
+DS.DjangoRESTAdapter = DS.RESTAdapter.extend({
+    defaultSerializer: "DS/djangoREST",
+
+    /**
+      Overrides the `pathForType` method to build underscored URLs.
+
+      Stolen from ActiveModelAdapter
+
+      ```js
+        this.pathForType("famousPerson");
+        //=> "famous_people"
+      ```
+
+      @method pathForType
+      @param {String} type
+      @returns String
+    */
+    pathForType: function(type) {
+        var decamelized = Ember.String.decamelize(type);
+        return Ember.String.pluralize(decamelized);
+    },
+
+
+    createRecord: function(store, type, record) {
+        var url = this.buildURL(type.typeKey);
+        var data = store.serializerFor(type.typeKey).serialize(record);
+        return this.ajax(url, "POST", { data: data });
+    },
+
+    updateRecord: function(store, type, record) {
+        var data = store.serializerFor(type.typeKey).serialize(record);
+        var id = get(record, 'id'); //todo find pk (not always id)
+        return this.ajax(this.buildURL(type.typeKey, id), "PUT", { data: data });
+    },
+
+    findMany: function(store, type, ids, parent) {
+        var adapter, root, url, endpoint, attribute;
+        adapter = this;
+
+        if (parent) {
+            attribute = this.getHasManyAttributeName(type, parent, ids);
+            endpoint = store.serializerFor(type.typeKey).keyForAttribute(attribute);
+            url = this.buildFindManyUrlWithParent(type, parent, endpoint);
+        } else {
+            Ember.assert("You need to add belongsTo for type (" + type.typeKey + "). No Parent for this record was found");
+        }
+
+        return this.ajax(url, "GET");
+    },
+
+    ajax: function(url, type, hash) {
+        hash = hash || {};
+        hash.cache = false;
+
+        return this._super(url, type, hash);
+    },
+
+    buildURL: function(type, id) {
+        var url = this._super(type, id);
+
+        if (url.charAt(url.length -1) !== '/') {
+            url += '/';
+        }
+
+        return url;
+    },
+
+    buildFindManyUrlWithParent: function(type, parent, endpoint) {
+        var root, url, parentValue;
+
+        parentValue = parent.get('id'); //todo find pk (not always id)
+        root = parent.constructor.typeKey;
+        url = this.buildURL(root, parentValue);
+
+        return url + endpoint + '/';
+    },
+
+    /**
+      Extract the attribute name given the parent record, the ids of the referenced model, and the type of
+      the referenced model.
+
+      Given the model definition
+
+      ````
+      App.User = DS.Model.extend({
+          username: DS.attr('string'),
+          aliases: DS.hasMany('speaker', { async: true})
+          favorites: DS.hasMany('speaker', { async: true})
+      });
+      ````
+
+      with a model object
+
+      ````
+      user1 = {
+          id: 1,
+          name: 'name',
+          aliases: [2,3],
+          favorites: [4,5]
+      }
+      
+      type = App.Speaker;
+      parent = user1;
+      ids = [4,5]
+      name = getHasManyAttributeName(type, parent, ids) // name === "favorites"
+      ````
+
+      @method getHasManyAttributeName
+      @param {subclass of DS.Model} type
+      @param {DS.Model} parent
+      @param {Array} ids
+      @returns String
+    */
+    getHasManyAttributeName: function(type, parent, ids) {
+      var attributeName;
+      parent.eachRelationship(function(name, relationship){
+        var relationshipIds;
+        if (relationship.kind === "hasMany" && relationship.type.typeKey === type.typeKey) {
+          relationshipIds = parent._data[name].mapBy('id');
+          // check if all of the requested ids are covered by this attribute
+          if (Ember.EnumerableUtils.intersection(ids, relationshipIds).length === ids.length) {
+            attributeName = name;
+          }
+        }
+      });
+
+      return attributeName;
+    }
+
+});
+
+
+})();