Initial commit

Author: Lee Richmond

.jshintrc

@@ -1,5 +1,6 @@
 {
   "predef": [
+    "server",
     "document",
     "window",
     "-Promise"

addon/mixins/model.js

@@ -0,0 +1,54 @@
+import Ember from 'ember';
+
+const resetRelations = function(record) {
+  record.eachRelationship((relationName, meta) => {
+    if (meta.kind === 'hasMany') {
+      record.set(relationName, Ember.A());
+    } else {
+      record.set(relationName, null);
+    }
+  });
+};
+
+const defaultOptions = function(options) {
+  if (options.resetRelations !== false) {
+    options.resetRelations = true;
+  }
+};
+
+export default Ember.Mixin.create({
+  hasDirtyAttributes: Ember.computed('currentState.isDirty', 'markedForDestruction', 'markedForDeletion', function() {
+    let original = this._super(...arguments);
+    return original || this.get('markedForDestruction') || this.get('markedForDeletion');
+  }),
+
+  markedForDeletion: Ember.computed('_markedForDeletion', function() {
+    return this.get('_markedForDeletion') || false;
+  }),
+
+  markedForDestruction: Ember.computed('_markedForDestruction', function() {
+    return this.get('_markedForDestruction') || false;
+  }),
+
+  markForDeletion() {
+    this.set('_markedForDeletion', true);
+  },
+
+  markForDestruction() {
+    this.set('_markedForDestruction', true);
+  },
+
+  // Blank out all relations after saving
+  // We will use the server response includes to 'reset'
+  // these relations
+  save(options = {}) {
+    defaultOptions(options);
+    let promise = this._super(...arguments);
+
+    if (options.resetRelations) {
+      promise.then(resetRelations);
+    }
+
+    return promise;
+  }
+});

addon/mixins/nested-relations.js

@@ -0,0 +1,162 @@
+import Ember from 'ember';
+
+const iterateRelations = function(record, relations, callback) {
+  Object.keys(relations).forEach((relationName) => {
+    let subRelations = relations[relationName];
+
+    let kind = record.relationshipFor(relationName).kind;
+    let relatedRecord = record.get(relationName);
+    relatedRecord = relatedRecord.get('content');
+
+    if (relatedRecord) {
+      callback(relationName, kind, relatedRecord, subRelations);
+    }
+  });
+};
+
+const isPresentObject = function(val) {
+  return val && Object.keys(val).length > 0;
+};
+
+const attributesFor = function(record) {
+  let attrs = {};
+
+  let changes = record.changedAttributes();
+  record.eachAttribute((name/* meta */) => {
+    if (record.get('isNew') || changes[name]) {
+      let value = record.get(name);
+
+      if (value !== undefined) {
+        attrs[name] = record.get(name);
+      }
+    }
+  });
+
+  if (record.get('markedForDeletion')) {
+    attrs = { _delete: true };
+  }
+
+  if (record.get('markedForDestruction')) {
+    attrs = { _destroy: true };
+  }
+
+  return attrs;
+};
+
+const jsonapiType = function(record) {
+  return record.store
+    .adapterFor(record.constructor.modelName)
+    .pathForType(record.constructor.modelName);
+};
+
+const jsonapiPayload = function(record) {
+  let attributes = attributesFor(record);
+
+  let payload = { type: jsonapiType(record) };
+
+  if (isPresentObject(attributes)) {
+    payload.attributes = attributes;
+  }
+
+  if (record.id) {
+    payload.id = record.id;
+  }
+
+  return payload;
+};
+
+const hasManyData = function(relatedRecords, subRelations) {
+  let payloads = [];
+  relatedRecords.forEach((relatedRecord) => {
+    if (relatedRecord.get('hasDirtyAttributes')) {
+      let payload = jsonapiPayload(relatedRecord);
+      processRelationships(subRelations, payload, relatedRecord);
+      payloads.push(payload);
+    }
+  });
+  return { data: payloads };
+};
+
+const belongsToData = function(relatedRecord, subRelations) {
+  if (isPresentObject(subRelations) || relatedRecord.get('hasDirtyAttributes')) {
+    let payload = jsonapiPayload(relatedRecord);
+    processRelationships(subRelations, payload, relatedRecord);
+    return { data: payload };
+  }
+};
+
+const processRelationship = function(kind, relationData, subRelations, callback) {
+  let payload = null;
+
+  if (kind === 'hasMany') {
+    payload = hasManyData(relationData, subRelations);
+  } else {
+    payload = belongsToData(relationData, subRelations);
+  }
+
+  if (payload && payload.data) {
+    callback(payload);
+  }
+};
+
+const processRelationships = function(relationshipHash, jsonData, record) {
+  if (isPresentObject(relationshipHash)) {
+    jsonData.relationships = {};
+
+    iterateRelations(record, relationshipHash, (name, kind, related, subRelations) => {
+      processRelationship(kind, related, subRelations, (payload) => {
+        jsonData.relationships[name] = payload;
+      });
+    });
+  }
+};
+
+const relationshipsDirective = function(value) {
+  let directive = {};
+
+  if (value) {
+    if (typeof(value) === 'string') {
+      directive[value] = {};
+    } else if(Array.isArray(value)) {
+      value.forEach((key) => {
+        Ember.merge(directive, relationshipsDirective(key));
+      });
+    } else {
+      Object.keys(value).forEach((key) => {
+        directive[key] = relationshipsDirective(value[key]);
+      });
+    }
+  } else {
+    return {};
+  }
+
+  return directive;
+};
+
+export default Ember.Mixin.create({
+  serialize(snapshot/*, options */) {
+    let json = this._super(...arguments);
+    delete(json.data.relationships);
+    delete(json.data.attributes);
+
+    let adapterOptions = snapshot.adapterOptions || {};
+
+    let attributes = attributesFor(snapshot.record);
+    if (isPresentObject(attributes)) {
+      json.data.attributes = attributes;
+    }
+
+    if (snapshot.record.id) {
+      json.data.id = snapshot.record.id.toString();
+    }
+
+    if (adapterOptions.attributes === false) {
+      delete(json.data.attributes);
+    }
+
+    let relationships = relationshipsDirective(adapterOptions.relationships);
+    processRelationships(relationships, json.data, snapshot.record);
+    console.log('serialized', json);
+    return json;
+  }
+});

bower.json

@@ -3,6 +3,9 @@
   "dependencies": {
     "ember": "~2.7.0",
     "ember-cli-shims": "0.1.1",
-    "ember-qunit-notifications": "0.1.0"
+    "ember-qunit-notifications": "0.1.0",
+    "pretender": "~1.1.0",
+    "Faker": "~3.1.0",
+    "materialize": "0.97.0"
   }
 }

ember-cli-build.js

@@ -7,6 +7,8 @@ module.exports = function(defaults) {
     // Add options here
   });
 
+  app.import('bower_components/materialize/dist/css/materialize.css', { prepend: true });
+
   /*
     This build file specifies the options for the dummy test app of this
     addon, located in `/tests/dummy`

package.json

@@ -27,23 +27,24 @@
     "ember-cli-htmlbars-inline-precompile": "^0.3.1",
     "ember-cli-inject-live-reload": "^1.4.0",
     "ember-cli-jshint": "^1.0.0",
+    "ember-cli-mirage": "0.2.1",
+    "ember-cli-page-object": "1.6.0",
     "ember-cli-qunit": "^2.0.0",
     "ember-cli-release": "^0.2.9",
     "ember-cli-sri": "^2.1.0",
     "ember-cli-test-loader": "^1.1.0",
     "ember-cli-uglify": "^1.2.0",
-    "ember-data": "^2.7.0",
     "ember-disable-prototype-extensions": "^1.1.0",
     "ember-export-application-global": "^1.0.5",
     "ember-load-initializers": "^0.5.1",
     "ember-resolver": "^2.0.3",
-    "ember-welcome-page": "^1.0.1",
     "loader.js": "^4.0.1"
   },
   "keywords": [
     "ember-addon"
   ],
   "dependencies": {
+    "ember-data": "^2.7.0",
     "ember-cli-babel": "^5.1.6"
   },
   "ember-addon": {

tests/.jshintrc

@@ -1,5 +1,6 @@
 {
   "predef": [
+    "server",
     "document",
     "window",
     "location",
@@ -21,7 +22,9 @@
     "andThen",
     "currentURL",
     "currentPath",
-    "currentRouteName"
+    "currentRouteName",
+    "test",
+    "QUnit"
   ],
   "node": false,
   "browser": false,

tests/acceptance/create-nested-relations-test.js

@@ -0,0 +1,24 @@
+import { test } from 'qunit';
+import moduleForAcceptance from '../../tests/helpers/module-for-acceptance';
+import page from 'dummy/tests/pages/post-form';
+import detailPage from 'dummy/tests/pages/show-post';
+
+moduleForAcceptance('Acceptance | create nested relations');
+
+test('creating a record with nested relations', function(assert) {
+  page
+    .visit()
+    .title.fillIn('my post');
+
+  page.addTag().tags(0).setName('new tag 1');
+  page.addTag().tags(1).setName('new tag 2');
+  page.addTag();
+  page.authorName.fillIn('John Doe');
+  page.submit();
+
+  andThen(function() {
+    assert.equal(detailPage.title, 'my post', 'saves basic attributes correctly');
+    assert.equal(detailPage.tagList, 'new tag 1, new tag 2', 'saves one-to-many correctly');
+    assert.equal(detailPage.authorName, 'John Doe', 'saves one-to-one correctly');
+  });
+});

tests/acceptance/delete-nested-object-test.js

@@ -0,0 +1,30 @@
+import { test } from 'qunit';
+import moduleForAcceptance from '../../tests/helpers/module-for-acceptance';
+import page from 'dummy/tests/pages/post-form';
+import detailPage from 'dummy/tests/pages/show-post';
+
+moduleForAcceptance('Acceptance | delete nested objects');
+
+test('deleting a nested object', function(assert) {
+  page.visit();
+  page.addTag().tags(0).setName('new tag 1');
+  page.submit();
+
+  andThen(function() {
+    assert.equal(detailPage.tagList, 'new tag 1');
+    detailPage.edit();
+
+    andThen(function() {
+      page.tags(0).remove();
+
+      andThen(function() {
+        assert.equal(page.tags().count, 0, 'should not show removed tag');
+        page.submit();
+
+        andThen(function() {
+          assert.equal(detailPage.tagList, '', 'should delete removed tag');
+        });
+      });
+    });
+  });
+});

tests/acceptance/update-nested-relations-test.js

@@ -0,0 +1,42 @@
+import { test } from 'qunit';
+import moduleForAcceptance from '../../tests/helpers/module-for-acceptance';
+import page from 'dummy/tests/pages/post-form';
+import detailPage from 'dummy/tests/pages/show-post';
+
+moduleForAcceptance('Acceptance | update nested relations');
+
+// Todo test ideally
+// * delete
+// * disassociate
+test('updating nested relations', function(assert) {
+  let author = server.create('author', { name: 'Joe Author' });
+  let tag1 = server.create('tag', { name: 'tag1' });
+  let tag2 = server.create('tag', { name: 'tag2' });
+  let post = server.create('post', {
+    author: author,
+    tags: [tag1, tag2],
+    title: 'test title'
+  });
+  visit(`/posts/${post.id}/edit`);
+
+  andThen(function() {
+    assert.equal(page.title.val, 'test title');
+    assert.equal(page.authorName.val, 'Joe Author');
+    assert.equal(page.tags().count, 2);
+    assert.equal(page.tags(0).name, 'tag1');
+    assert.equal(page.tags(1).name, 'tag2');
+
+    page.authorName.fillIn('new author');
+    page.tags(1).setName('tag2 changed');
+    page.addTag();
+    page.tags(2).setName('new tag');
+    page.submit();
+
+    andThen(function() {
+      post.reload();
+      assert.equal(post.author.id, author.id, 'updates existing author');
+      assert.equal(detailPage.authorName, 'new author', 'updates author name');
+      assert.equal(detailPage.tagList, 'tag1, tag2 changed, new tag', 'updates one-to-many correctly');
+    });
+  });
+});