ember-data-factory-guy 0.1

data/dist/ember-data-factory-guy.min.js

@@ -0,0 +1 @@
+FactoryGuy=Ember.Object.reopenClass({fixtureStore:{},fixtureLookup:{},modelIds:{},define:function(model,config){var info=this.getModelInfo(model);for(key in config){var value=config[key];info[key]=value;if(key!="default"){this.fixtureLookup[key]=model}}this.modelIds[model]=0},getModelInfo:function(model){if(!this.fixtureStore[model]){this.fixtureStore[model]={}}return this.fixtureStore[model]},lookupModelForName:function(name){var model=this.fixtureLookup[name];if(!model){if(this.fixtureStore[name]){model=name}}return model},generateId:function(model){var lastId=this.modelIds[model]||0;this.modelIds[model]=lastId+1;return this.modelIds[model]},build:function(name,opts){var model=this.lookupModelForName(name);if(!model){throw new Error("can't find that factory named ["+name+"]")}var modelInfo=this.fixtureStore[model];var modelAttributes=modelInfo[name]||{};var defaultModelAttributes=modelInfo.default;var fixture=$.extend({},defaultModelAttributes,modelAttributes,opts);fixture.id=this.generateId(model);return fixture},resetModels:function(store){var typeMaps=store.typeMaps;if(store.usingFixtureAdapter()){for(typeKey in this.fixtureStore){var modelType=store.modelFor(typeKey);modelType.FIXTURES=[];store.unloadAll(modelType)}}else{for(model in typeMaps){if(typeMaps[model].type.typeKey!="user"){store.unloadAll(typeMaps[model].type)}}}this.modelIds={}},pushFixture:function(modelClass,fixture){if(!modelClass["FIXTURES"]){modelClass["FIXTURES"]=[]}modelClass["FIXTURES"].push(fixture);return fixture}});DS.Store.reopen({usingFixtureAdapter:function(){var adapter=this.adapterFor("application");return adapter instanceof DS.FixtureAdapter},makeFixture:function(name,options){var modelName=FactoryGuy.lookupModelForName(name);var fixture=FactoryGuy.build(name,options);var modelType=this.modelFor(modelName);if(this.usingFixtureAdapter()){this.setBelongsToFixturesAssociation(modelType,modelName,fixture);return FactoryGuy.pushFixture(modelType,fixture)}else{var self=this;var model;Em.run(function(){model=self.push(modelName,fixture);self.setBelongsToRestAssociation(modelType,modelName,model)});return model}},setBelongsToFixturesAssociation:function(modelType,modelName,parentFixture){var store=this;var adapter=this.adapterFor("application");var relationShips=Ember.get(modelType,"relationshipNames");if(relationShips.hasMany){relationShips.hasMany.forEach(function(relationship){var hasManyModel=store.modelFor(Em.String.singularize(relationship));if(parentFixture[relationship]){parentFixture[relationship].forEach(function(id){var hasManyfixtures=adapter.fixturesForType(hasManyModel);var fixture=adapter.findFixtureById(hasManyfixtures,id);fixture[modelName]=parentFixture.id})}})}},setBelongsToRestAssociation:function(modelType,modelName,parent){var relationShips=Ember.get(modelType,"relationshipNames");if(relationShips.hasMany){relationShips.hasMany.forEach(function(name){var children=parent.get(name);if(children.get("length")>0){children.forEach(function(child){child.set(modelName,parent)})}})}},pushPayload:function(type,payload){if(this.usingFixtureAdapter()){var model=this.modelFor(modelName);FactoryGuy.pushFixture(model,payload)}else{this._super(type,payload)}}});DS.FixtureAdapter.reopen({createRecord:function(store,type,record){var promise=this._super(store,type,record);promise.then(function(){var hasManyName=Ember.String.pluralize(type.typeKey);var relationShips=Ember.get(type,"relationshipNames");if(relationShips.belongsTo){}});return promise}});FactoryGuyHelperMixin=Em.Mixin.create({setup:function(app){this.set("container",app.__container__);return this},useFixtureAdapter:function(app){app.ApplicationAdapter=DS.FixtureAdapter;this.getStore().adapterFor("application").simulateRemoteResponse=false},find:function(type,id){return this.getStore().find(type,id)},make:function(name,opts){return this.getStore().makeFixture(name,opts)},getStore:function(){return this.get("container").lookup("store:main")},pushPayload:function(type,hash){return this.getStore().pushPayload(type,hash)},pushRecord:function(type,hash){return this.getStore().push(type,hash)},stubEndpointForHttpRequest:function(url,json,options){options=options||{};var request={url:url,dataType:"json",responseText:json,type:options.type||"GET",status:options.status||200};if(options.data){request.data=options.data}$.mockjax(request)},handleCreate:function(name,opts){var model=FactoryGuy.lookupModelForName(name);this.stubEndpointForHttpRequest("/"+Em.String.pluralize(model),this.buildAjaxResponse(name,opts),{type:"POST"})},buildAjaxResponse:function(name,opts){var fixture=FactoryGuy.build(name,opts);var model=FactoryGuy.lookupModelForName(name);var hash={};hash[model]=fixture;return hash},handleUpdate:function(root,id){this.stubEndpointForHttpRequest("/"+Em.String.pluralize(root)+"/"+id,"{}",{type:"PUT"})},handleDelete:function(root,id){this.stubEndpointForHttpRequest("/"+Em.String.pluralize(root)+"/"+id,{},{type:"DELETE"})},teardown:function(){FactoryGuy.resetModels(this.getStore())}});

data/ember-data-factory-guy.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = "ember-data-factory-guy"
+  s.version     = "0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["daniel sudol", "alex opak"]
+  s.email       = ["dansudol@yahoo.com"]
+  s.homepage    = "http://rubygems.org/gems/ember-data-factory-guy"
+  s.summary     = "Create Fixtures for Ember Data"
+  s.description = "Create Fixtures for Ember Data"
+  s.license     = "MIT"
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "ember-data-factory-guy"
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {tests}/*`.split("\n")
+
+  s.require_paths = ["lib"]
+end

data/lib/ember-data-factory-guy.rb

@@ -0,0 +1,13 @@
+module EmberDataFixtureFactory
+  if defined? ::Rails::Engine
+    # auto wire assets as Rails Engine
+    class Rails < ::Rails::Engine
+    end
+
+  elsif defined? ::Sprockets
+    root_dir = File.expand_path(File.dirname(File.dirname(__FILE__)))
+    # Set up asset paths for Sprockets apps
+    p "root_dir #{root_dir} #{File.join(root_dir, "vendor", "assets", "javascripts")}"
+    ::Sprockets.append_path File.join(root_dir, "vendor", "assets", "javascripts")
+  end
+end

data/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "ember-data-factory-guy",
+  "version": "0.0.1",
+  "authors": [
+    "Opak Alex <opak.alexandr@gmail.com>",
+    "Daniel Sudol <dansudol@yahoo.com>"
+  ],
+  "description": "Factory for testing Ember application",
+  "main": "dist/ember-data-factory-guy.js",
+  "keywords": [
+    "Factory",
+    "Ember",
+    "Data",
+    "FixtureAdapter"
+  ],
+  "license": "MIT",
+
+  "bugs": {
+    "url": ""
+  },
+
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+
+  "devDependencies": [
+    "grunt-contrib-coffee",
+    "grunt-contrib-concat",
+    "grunt-contrib-uglify",
+    "grunt-contrib-qunit"
+  ],
+
+  "engines": {
+    "node": ">=v0.10.1"
+  }
+}

data/src/factory_guy.js

@@ -0,0 +1,144 @@
+FactoryGuy = Ember.Object.reopenClass({
+  fixtureStore: {},
+  fixtureLookup: {},
+  modelIds: {},
+
+  /**
+   ```javascript
+
+     User = DS.Model.extend({
+        name: DS.attr('string'),
+     })
+
+     FactoryGuy.define('user', {
+        default: {
+          name: "Fred"
+        },
+
+        bob: {
+          name: "Bob"
+        }
+     });
+
+    ```
+
+     For the User model, you can define fixtures like 'bob' or just use 'user'
+     and get default values.
+
+     And to get those fixtures you would call them this way:
+
+      FactoryGuy.build('user') or FactoryGuy.build('bob')
+
+    @param model the model to define
+    @param config your default and specific fixtures
+   */
+  define: function (model, config) {
+    var info = this.getModelInfo(model);
+    for (key in config) {
+      var value = config[key];
+      info[key] = value;
+      if (key != 'default') {
+        this.fixtureLookup[key] = model;
+      }
+    }
+    // setup id
+    this.modelIds[model] = 0;
+  },
+
+  /**
+
+    @param model
+   */
+  getModelInfo: function (model) {
+    if (!this.fixtureStore[model]) {
+      this.fixtureStore[model] = {};
+    }
+    return this.fixtureStore[model];
+  },
+
+  /**
+
+    @param name fixture name
+    @returns model associated with fixture name
+   */
+  lookupModelForName: function (name) {
+    var model = this.fixtureLookup[name];
+    if (!model) {
+      if (this.fixtureStore[name]) {
+        model = name;
+      }
+    }
+    return model;
+  },
+
+  /**
+    Generate next id for model
+   */
+  generateId: function (model) {
+    var lastId = this.modelIds[model] || 0;
+    this.modelIds[model] = lastId + 1;
+    return this.modelIds[model];
+  },
+
+  /**
+    Build fixtures for model or specific fixture name. For example:
+
+      FactoryGuy.build('user') for User model
+      FactoryGuy.build('bob') for User model with bob attributes
+
+    @param name fixture name
+    @param opts options that will override default fixture values
+    @returns {*}
+   */
+  build: function (name, opts) {
+    var model = this.lookupModelForName(name);
+    if (!model) {
+      throw new Error("can't find that factory named [" + name + "]");
+    }
+
+    var modelInfo = this.fixtureStore[model];
+    var modelAttributes = modelInfo[name] || {};
+    var defaultModelAttributes = modelInfo.default;
+    var fixture = $.extend({}, defaultModelAttributes, modelAttributes, opts);
+    fixture.id = this.generateId(model);
+    return fixture;
+  },
+
+  /**
+    Clear model instances from FIXTURES array, and from store cache.
+    Reset the id sequence for the models back to zero.
+   */
+  resetModels: function (store) {
+    var typeMaps = store.typeMaps;
+    if (store.usingFixtureAdapter()) {
+      for (typeKey in this.fixtureStore) {
+        var modelType = store.modelFor(typeKey);
+        modelType.FIXTURES = [];
+        store.unloadAll(modelType);
+      }
+    } else {
+      for (model in typeMaps) {
+        if (typeMaps[model].type.typeKey != 'user') {
+//          console.log(typeMaps[model].type.typeKey)
+          store.unloadAll(typeMaps[model].type);
+        }
+      }
+    }
+    this.modelIds = {}
+  },
+
+  /**
+    Push fixture to model's FIXTURES array.
+    Used when store's adapter is a DS.FixtureAdapter.
+
+    @param modelClass DS.Model type
+    @param fixture the fixture to add
+   */
+  pushFixture: function (modelClass, fixture) {
+    if (!modelClass['FIXTURES']) {
+      modelClass['FIXTURES'] = [];
+    }
+    modelClass['FIXTURES'].push(fixture);
+    return fixture;
+  }
+})

data/src/factory_guy_helper_mixin.js

@@ -0,0 +1,89 @@
+FactoryGuyHelperMixin = Em.Mixin.create({
+
+  setup: function(app) {
+    this.set('container', app.__container__);
+    return this;
+  },
+
+  useFixtureAdapter: function(app) {
+    app.ApplicationAdapter = DS.FixtureAdapter;
+    this.getStore().adapterFor('application').simulateRemoteResponse = false;
+  },
+
+  find: function(type, id) {
+    return this.getStore().find(type, id);
+  },
+
+  make: function(name, opts) {
+    return this.getStore().makeFixture(name, opts);
+  },
+
+  getStore: function () {
+    return this.get('container').lookup('store:main');
+  },
+
+  pushPayload: function(type, hash) {
+    return this.getStore().pushPayload(type, hash);
+  },
+
+  pushRecord: function(type, hash) {
+    return this.getStore().push(type, hash);
+  },
+
+  stubEndpointForHttpRequest: function (url, json, options) {
+    options = options || {};
+    var request = {
+      url: url,
+      dataType: 'json',
+      responseText: json,
+      type: options.type || 'GET',
+      status: options.status || 200
+    }
+
+    if (options.data) {
+      request.data = options.data
+    }
+
+    $.mockjax(request);
+  },
+
+  /**
+   * Handling ajax POST for a model
+   *
+   * @param name of the fixture ( or model ) to create
+   * @param opts fixture options
+   */
+  handleCreate: function (name, opts) {
+    var model = FactoryGuy.lookupModelForName(name);
+    this.stubEndpointForHttpRequest(
+      "/" + Em.String.pluralize(model),
+      this.buildAjaxResponse(name, opts),
+      {type: 'POST'}
+    )
+  },
+
+  buildAjaxResponse: function (name, opts) {
+    var fixture = FactoryGuy.build(name, opts);
+    var model = FactoryGuy.lookupModelForName(name);
+    var hash = {};
+    hash[model] = fixture;
+    return hash;
+  },
+
+  handleUpdate: function (root, id) {
+    this.stubEndpointForHttpRequest(
+      "/" + Em.String.pluralize(root) + "/" + id, {}, {type: 'PUT'}
+    )
+  },
+
+  handleDelete: function (root, id) {
+    this.stubEndpointForHttpRequest(
+      "/" + Em.String.pluralize(root) + "/" + id, {}, {type: 'DELETE'}
+    )
+  },
+
+  teardown: function () {
+    FactoryGuy.resetModels(this.getStore());
+  }
+
+})

data/src/has_many.js

@@ -0,0 +1,188 @@
+(function(){
+  var get = Ember.get, set = Ember.set, setProperties = Ember.setProperties;
+
+  function asyncHasMany(record, type, options, meta) {
+    var relationship = record._relationships[key],
+      promiseLabel = "DS: Async hasMany " + record + " : " + key;
+
+    if (!relationship) {
+      var resolver = Ember.RSVP.defer(promiseLabel);
+      relationship = buildRelationship(record, key, options, function(store, data) {
+        var link = data.links && data.links[key];
+        var rel;
+        if (link) {
+          rel = store.findHasMany(record, link, meta, resolver);
+        } else {
+          rel = store.findMany(record, data[key], meta.type, resolver);
+        }
+        // cache the promise so we can use it
+        // when we come back and don't need to rebuild
+        // the relationship.
+        set(rel, 'promise', resolver.promise);
+        return rel;
+      });
+    }
+
+    var promise = relationship.get('promise').then(function() {
+      return relationship;
+    }, null, "DS: Async hasMany records received");
+
+    return DS.PromiseArray.create({
+      promise: promise
+    });
+  }
+
+  function buildRelationship(record, key, options, callback) {
+    var rels = record._relationships;
+
+    if (rels[key]) { return rels[key]; }
+
+    var data = get(record, 'data'),
+      store = get(record, 'store');
+
+    var relationship = rels[key] = callback.call(record, store, data);
+
+    return setProperties(relationship, {
+      owner: record,
+      name: key,
+      isPolymorphic: options.polymorphic
+    });
+  }
+
+  function hasRelationship(type, options) {
+    options = options || {};
+
+    var meta = {
+      type: type,
+      isRelationship: true,
+      options: options,
+      kind: 'hasMany'
+    };
+
+    return Ember.computed('data', function(key) {
+      var adapter = this.store.adapterFor('application');
+      if (adapter.toString().match('Fixture')) {
+        var relationship = this._relationships[key],
+            promiseLabel = "DS: Async hasMany " + this + " : " + key;
+
+        if (!relationship) {
+          var resolver = Ember.RSVP.defer(promiseLabel);
+          relationship = buildRelationship(this, key, options, function(store, data) {
+            var link = data.links && data.links[key];
+            var rel;
+            if (link) {
+              rel = store.findHasMany(this, link, meta, resolver);
+            } else {
+              rel = store.findMany(this, data[key], meta.type, resolver);
+            }
+            // cache the promise so we can use it
+            // when we come back and don't need to rebuild
+            // the relationship.
+            set(rel, 'promise', resolver.promise);
+            return rel;
+          });
+        }
+
+        var promise = relationship.get('promise').then(function() {
+          return relationship;
+        }, null, "DS: Async hasMany records received");
+
+        return DS.PromiseArray.create({
+          promise: promise
+        });
+      }
+
+      return buildRelationship(this, key, options, function(store, data) {
+        var records = data[key];
+        Ember.assert("You looked up the '" + key + "' relationship on '" + this + "' but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`DS.hasMany({ async: true })`)", Ember.A(records).everyProperty('isEmpty', false));
+        return store.findMany(this, data[key], meta.type);
+      });
+    }).meta(meta).readOnly();
+  }
+
+  /**
+   `DS.hasMany` is used to define One-To-Many and Many-To-Many
+   relationships on a [DS.Model](/api/data/classes/DS.Model.html).
+
+   `DS.hasMany` takes an optional hash as a second parameter, currently
+   supported options are:
+
+   - `async`: A boolean value used to explicitly declare this to be an async relationship.
+   - `inverse`: A string used to identify the inverse property on a related model.
+
+   #### One-To-Many
+   To declare a one-to-many relationship between two models, use
+   `DS.belongsTo` in combination with `DS.hasMany`, like this:
+
+   ```javascript
+   App.Post = DS.Model.extend({
+        comments: DS.hasMany('comment')
+      });
+
+   App.Comment = DS.Model.extend({
+        post: DS.belongsTo('post')
+      });
+   ```
+
+   #### Many-To-Many
+   To declare a many-to-many relationship between two models, use
+   `DS.hasMany`:
+
+   ```javascript
+   App.Post = DS.Model.extend({
+        tags: DS.hasMany('tag')
+      });
+
+   App.Tag = DS.Model.extend({
+        posts: DS.hasMany('post')
+      });
+   ```
+
+   #### Explicit Inverses
+
+   Ember Data will do its best to discover which relationships map to
+   one another. In the one-to-many code above, for example, Ember Data
+   can figure out that changing the `comments` relationship should update
+   the `post` relationship on the inverse because post is the only
+   relationship to that model.
+
+   However, sometimes you may have multiple `belongsTo`/`hasManys` for the
+   same type. You can specify which property on the related model is
+   the inverse using `DS.hasMany`'s `inverse` option:
+
+   ```javascript
+   var belongsTo = DS.belongsTo,
+   hasMany = DS.hasMany;
+
+   App.Comment = DS.Model.extend({
+        onePost: belongsTo('post'),
+        twoPost: belongsTo('post'),
+        redPost: belongsTo('post'),
+        bluePost: belongsTo('post')
+      });
+
+   App.Post = DS.Model.extend({
+        comments: hasMany('comment', {
+          inverse: 'redPost'
+        })
+      });
+   ```
+
+   You can also specify an inverse on a `belongsTo`, which works how
+   you'd expect.
+
+   @namespace
+   @method hasMany
+   @for DS
+   @param {String or DS.Model} type the model type of the relationship
+   @param {Object} options a hash of options
+   @return {Ember.computed} relationship
+   */
+  DS.hasMany = function(type, options) {
+    if (typeof type === 'object') {
+      options = type;
+      type = undefined;
+    }
+    return hasRelationship(type, options);
+  }
+}).call();