sproutcore 1.6.0.rc.1-x86-mingw32 → 1.6.0.rc.2-x86-mingw32

data/lib/frameworks/sproutcore/frameworks/core_foundation/system/event.js

@@ -287,7 +287,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     // Get the handlers queue for this element/eventType.  If the queue does
     // not exist yet, create it and also setup the shared listener for this
     // eventType.
-    var events = SC.data(elem, "events") || SC.data(elem, "events", {}) ,
+    var events = SC.data(elem, "sc_events") || SC.data(elem, "sc_events", {}) ,
         handlers = events[eventType]; 
     if (!handlers) {
       handlers = events[eventType] = {} ;
@@ -351,7 +351,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     // around, causing it to be cloned in the process
     if (SC.browser.msie && elem.setInterval) elem = window;
 
-    var handlers, key, events = SC.data(elem, "events") ;
+    var handlers, key, events = SC.data(elem, "sc_events") ;
     if (!events) return this ; // nothing to do if no events are registered
 
     // if no type is provided, remove all types for this element.
@@ -396,7 +396,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
       key = null ;
       for(key in events) break;
       if(!key) {
-        SC.removeData(elem, "events") ;
+        SC.removeData(elem, "sc_events") ;
         delete this._elements[SC.guidFor(elem)]; // important to avoid leaks
       }
       
@@ -546,7 +546,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     args[0] = event = SC.Event.normalizeEvent(event || window.event);
 
     // get the handlers for this event type
-    handlers = (SC.data(this, "events") || {})[event.type];
+    handlers = (SC.data(this, "sc_events") || {})[event.type];
     if (!handlers) return NO ; // nothing to do
     
     // invoke all handlers

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/mixins/template_helpers/text_field_support.js

@@ -190,4 +190,13 @@
     SC.RootResponder.responder.keyup(new SC.Event({ type: 'keyup', keyCode: 27 }));
     equals(cancelCalled, 1, "calls cancel after pressing escape key");
   });
+
+  test("creates textarea tag if isMultiline", function() {
+    var view = SC.TextField.create({
+      isMultiline: YES
+    });
+    SC.run(function() { pane.appendChild(view); });
+    equals(view.$('textarea').length, 1, "view creates textarea tag instead of input");
+  });
+
 })();

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/template/collection.js

@@ -272,3 +272,113 @@ test("should allow changing content property to be null", function() {
   view.set('content', null);
   equals(view.$('li').length, 0, "should not create any li elements");
 });
+
+test("collection view within a collection view with default content should render content once", function() {
+  TemplateTests.InnerCollectionView = SC.TemplateCollectionView.extend();
+
+  TemplateTests.OuterItemView = SC.TemplateView.extend({
+    template: SC.Handlebars.compile('{{#collection "TemplateTests.InnerCollectionView" content=content.things}} {{content}} {{/collection}}')
+  });
+
+  TemplateTests.OuterCollectionView = SC.TemplateCollectionView.extend({
+    content: [
+      SC.Object.create({things: ['1', '2', '3']}),
+      SC.Object.create({things: ['4', '5']}),
+      SC.Object.create({things: ['6']})
+    ],
+    itemView: TemplateTests.OuterItemView
+  });
+
+  var view = SC.TemplateView.create({
+    template: SC.Handlebars.compile('{{collection "TemplateTests.OuterCollectionView"}}')
+  });
+
+  view.createLayer();
+
+  equals(view.$('ul ul:eq(0) li').length, 3, 'first nested collection view should have 3 list items');
+  equals(view.$('ul ul:eq(1) li').length, 2, 'second nested collection view should have 2 list items');
+  equals(view.$('ul ul:eq(2) li').length, 1, 'third nested collection view should have 1 list items');
+});
+
+test("collection view within a collection view should have the right childViews", function() {
+  TemplateTests.InnerCollectionView = SC.TemplateCollectionView.extend();
+
+  TemplateTests.OuterItemView = SC.TemplateView.extend({
+    template: SC.Handlebars.compile('{{#collection "TemplateTests.InnerCollectionView" content=content.things}} {{content}} {{/collection}}')
+  });
+
+  TemplateTests.OuterCollectionView = SC.TemplateCollectionView.extend({
+    content: [
+      SC.Object.create({things: ['1', '2', '3']}),
+      SC.Object.create({things: ['4', '5']}),
+      SC.Object.create({things: ['6']})
+    ],
+    itemView: TemplateTests.OuterItemView
+  });
+
+  var view = SC.TemplateView.create({
+    template: SC.Handlebars.compile('{{collection "TemplateTests.OuterCollectionView"}}')
+  });
+
+  view.createLayer();
+
+  var outer       = view.childViews[0];
+  var firstInner  = outer.childViews[0].childViews[0];
+  var secondInner = outer.childViews[1].childViews[0];
+  var thirdInner  = outer.childViews[2].childViews[0];
+
+  ok(outer.kindOf(TemplateTests.OuterCollectionView), 'first child view should be instance of outer collection view');
+  ok(firstInner.kindOf(TemplateTests.InnerCollectionView), 'first child view of outer should be instance of inner');
+  ok(secondInner.kindOf(TemplateTests.InnerCollectionView), 'second child view of outer should be instance of inner');
+  ok(thirdInner.kindOf(TemplateTests.InnerCollectionView), 'third child view of outer should be instance of inner');
+});
+
+test("should render inverse template when its present and there is no content", function() {
+  TemplateTests.CollectionTestView = SC.TemplateCollectionView.create({
+    content: [],
+    inverseTemplate: SC.Handlebars.compile('<h1>inverse<h1>')
+  });
+
+  var view = SC.TemplateView.create({
+    template: SC.Handlebars.compile('{{collection "TemplateTests.CollectionTestView"}}')
+  });
+
+  view.createLayer();
+
+  equals(view.$('h1').text(), 'inverse', 'collection view with no content and inverse template should render inverse template')
+});
+
+test("should render inverse template name when its present and there is no content", function() {
+  TemplateTests.CollectionTestView = SC.TemplateCollectionView.create({
+    content: [],
+    inverseTemplateName: 'inverse_template',
+
+    templates: SC.Object.create({
+      inverse_template: function(dataSource) {
+        return "<h1>inverse template from file</h1>";
+      }
+    })
+  });
+
+  var view = SC.TemplateView.create({
+    template: SC.Handlebars.compile('{{collection "TemplateTests.CollectionTestView"}}')
+  });
+
+  view.createLayer();
+
+  equals(view.$('h1').text(), 'inverse template from file', 'collection view with no content and inverse template name should render template')
+});
+
+test("#collection helper should allow relative paths for the collection view class", function() {
+  var view = SC.TemplateView.create({
+    template: SC.Handlebars.compile('{{#collection "myCollectionView"}}{{content}}{{/collection}}'),
+    myCollectionView: SC.TemplateCollectionView.create({
+      content: ['foo', 'bar', 'baz']
+    })
+  });
+
+  SC.run(function() { view.createLayer(); });
+
+  equals(view.$('li').length, 3, '#collection should find relative collection view path');
+});
+

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/template_collection.js

@@ -30,6 +30,12 @@ SC.TemplateCollectionView = SC.TemplateView.extend(
   // In case a default content was set, trigger the child view creation
   // as soon as the empty layer was created
   didCreateLayer: function() {
+    // FIXME: didCreateLayer gets called multiple times when template collection
+    // views are nested - this is a hack to avoid rendering the content more
+    // than once.
+    if (this._sctcv_layerCreated) { return; }
+    this._sctcv_layerCreated = true;
+
     var content = this.get('content');
     if(content) {
       this.arrayContentDidChange(0, 0, content.get('length'));
@@ -64,6 +70,37 @@ SC.TemplateCollectionView = SC.TemplateView.extend(
   */
   itemViewTemplateName: null,
 
+  /**
+    A template to render when there is no content or the content length is 0.
+  */
+  inverseTemplate: function(key, value) {
+    if (value !== undefined) {
+      return value;
+    }
+
+    var templateName = this.get('inverseTemplateName'),
+        template = this.get('templates').get(templateName);
+
+    if (!template) {
+      //@if(debug)
+      if (templateName) {
+        SC.Logger.warn('%@ - Unable to find template "%@".'.fmt(this, templateName));
+      }
+      //@endif
+
+      return function() { return ''; };
+    }
+
+    return template;
+  }.property('inverseTemplateName').cacheable(),
+
+  /**
+    The name of a template to lookup if no inverse template is provided.
+
+    @property {String}
+  */
+  inverseTemplateName: null,
+
   itemContext: null,
 
   itemViewClass: function() {
@@ -207,42 +244,42 @@ SC.TemplateCollectionView = SC.TemplateView.extend(
       delete itemOptions['class'];
       delete itemOptions.classBinding;
 
-      for (idx = 0; idx < len; idx++) {
-        item = addedObjects.objectAt(idx);
-        view = this.createChildView(itemViewClass.extend(itemOptions, {
-          content: item,
-          render: renderFunc,
-          tagName: itemViewClass.prototype.tagName || this.get('itemTagName')
-        }));
-
-        var contextProperty = view.get('contextProperty');
-        if (contextProperty) {
-          view.set('context', view.get(contextProperty));
-        }
-
-        itemElem = view.createLayer().$();
-        if (!insertAtElement) {
-          elem.append(itemElem);
-        } else {
-          itemElem.insertAfter(insertAtElement);
-        }
-        insertAtElement = itemElem;
-
-        addedViews.push(view);
+    for (idx = 0; idx < len; idx++) {
+      item = addedObjects.objectAt(idx);
+      childView = this.createChildView(itemViewClass.extend(itemOptions, {
+        content: item,
+        render: renderFunc,
+        tagName: itemViewClass.prototype.tagName || this.get('itemTagName')
+      }));
+
+      var contextProperty = childView.get('contextProperty');
+      if (contextProperty) {
+        childView.set('context', childView.get(contextProperty));
+      }
+
+      itemElem = childView.createLayer().$();
+      if (!insertAtElement) {
+        elem.append(itemElem);
+      } else {
+        itemElem.insertAfter(insertAtElement);
       }
+      insertAtElement = itemElem;
+
+      addedViews.push(childView);
+    }
 
       childViews.replace(start, 0, addedViews);
     }
 
     var inverseTemplate = this.get('inverseTemplate');
     if (childViews.get('length') === 0 && inverseTemplate) {
-      view = this.createChildView(SC.TemplateView.extend({
+      childView = this.createChildView(SC.TemplateView.extend({
         template: inverseTemplate,
         content: this
       }));
-      this.set('emptyView', view);
-      view.createLayer().$().appendTo(elem);
-      this.childViews = [view];
+      this.set('emptyView', childView);
+      childView.createLayer().$().appendTo(elem);
+      this.childViews = [childView];
     }
 
     // Because the layer has been modified, we need to invalidate the frame

data/lib/frameworks/sproutcore/frameworks/datastore/system/child_array.js

@@ -172,7 +172,11 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
     newRecs = this._processRecordsToHashes(recs);
     children.replace(idx, amt, newRecs);
     // notify that the record did change...
-    if (newRecs !== this._prevChildren) this.recordPropertyDidChange();
+    if (newRecs !== this._prevChildren){
+      this._performRecordPropertyChange(null, false);
+      this.arrayContentWillChange(idx, amt, len);
+      this._childrenContentDidChange(idx, amt, len);
+    } 
     record.recordDidChange(pname);
 
     return this;
@@ -219,10 +223,25 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
     @returns {SC.ChildArray} itself.
   */
   recordPropertyDidChange: function(keys) {
+    this._performRecordPropertyChange(keys, true);
+    return this;
+  },
+  
+  /** @private
+    Invoked when the object is changed from the parent or an outside source
+    
+    will cause the entire array to reset
+    
+    @param {SC.Array} keys optional
+    @param {Boolean} doReset optional
+    @returns {SC.ChildArray} itself.
+  */
+  _performRecordPropertyChange: function(keys, doReset){
     if (keys && !keys.contains(this.get('propertyName'))) return this;
 
     var children = this.get('readOnlyChildren'), oldLen = 0, newLen = 0;
     var prev = this._prevChildren, f = this._childrenContentDidChange;
+    doReset = SC.none(doReset) ? true : doReset;
 
     if (children === prev) return this; // nothing to do
 
@@ -245,11 +264,12 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
 
       newLen = children.get('length');
     }
-
-    
-    this.arrayContentWillChange(0, oldLen, newLen);
     this._prevChildren = children;
-    this._childrenContentDidChange(0, oldLen, newLen);
+    
+    if (doReset){
+      this.arrayContentWillChange(0, oldLen, newLen);
+      this._childrenContentDidChange(0, oldLen, newLen);      
+    }
 
     return this;
   },

data/lib/frameworks/sproutcore/frameworks/datastore/system/record_array.js

@@ -316,11 +316,11 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
 
     @returns {SC.RecordArray}
   */
-  find: function(query, target) {
+  find: function(original, query, target) {
     if (query && query.isQuery) {
       return this.get('store').find(query.queryWithScope(this));
-    } else return sc_super();
-  },
+    } else return original.apply(this, SC.$A(arguments).slice(1));
+  }.enhance(),
 
   /**
     Call whenever you want to refresh the results of this query.  This will

data/lib/frameworks/sproutcore/frameworks/datastore/tests/models/nested_records/nested_record_array.js

@@ -378,7 +378,30 @@ test("pushObject should trigger an arrayContentDidChange with only 1 added item"
   testParent.get('elements').pushObject({});
 
   equals(didChangeCalls.length, 1, 'didChange should only be called once');
-  equals(didChangeCalls[0][0], 0, 'didChange should be called with a start index of 0 because we can\'t be sure about the order from the server');
-  equals(didChangeCalls[0][1], 4, 'didChange should be called with a removed count of 4');
-  equals(didChangeCalls[0][2], 5, 'didChange should be called with an added count of 5 because the items could have changed order on the server');
+  equals(didChangeCalls[0][0], 4, 'didChange should be called with a start index of 4');
+  equals(didChangeCalls[0][1], 0, 'didChange should be called with a removed count of 0');
+  equals(didChangeCalls[0][2], 1, 'didChange should be called with an added count of 1');
+});
+
+test("replace should trigger an arrayContentDidChange with only 1 added item", function() {
+  var didChangeCalls = [], target;
+
+  target = SC.Object.create({
+    willChange: function() {},
+    didChange: function() {
+      didChangeCalls.push(arguments);
+    }
+  });
+
+  testParent.get('elements').addArrayObservers({
+    target: target,
+    willChange: 'willChange',
+    didChange: 'didChange'
+  });
+  testParent.get('elements').replace(3, 1, [{}]);
+
+  equals(didChangeCalls.length, 1, 'didChange should only be called once');
+  equals(didChangeCalls[0][0], 3, 'didChange should be called with a start index of 3');
+  equals(didChangeCalls[0][1], 1, 'didChange should be called with a removed count of 1');
+  equals(didChangeCalls[0][2], 1, 'didChange should be called with an added count of 1');
 });

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/record_array/core_methods.js

@@ -6,22 +6,28 @@
 /*globals module ok equals same test MyApp */
 
 // test core array-mapping methods for RecordArray
-var store, storeKey, json, rec, storeKeys, recs;
+var store, storeKey, json, rec, storeKey2, json2, rec2, storeKeys, recs;
 module("SC.RecordArray core methods", {
   setup: function() {
     // setup dummy store
     store = SC.Store.create();
+
     storeKey = SC.Record.storeKeyFor('foo');
-    json = {  guid: "foo", foo: "bar" };
-    store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN); 
-    
-    
-    // get record
+    json = { guid: "foo", foo: "bar" };
+    store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+
+    storeKey2 = SC.Record.storeKeyFor('baz');
+    json2 = { guid: "baz", baz: "bash" };
+    store.writeDataHash(storeKey2, json2, SC.Record.READY_CLEAN);
+
+    // get records
     rec = store.materializeRecord(storeKey);
-    equals(rec.get('foo'), 'bar', 'record should have json');
-    
+    equals(rec.get('foo'), 'bar', 'precond - record should have json');
+    rec2 = store.materializeRecord(storeKey2);
+    equals(rec2.get('baz'), 'bash', 'precond - record 2 should have json');
+
     // get record array.
-    storeKeys = [storeKey];
+    storeKeys = [storeKey, storeKey2];
     recs = SC.RecordArray.create({ store: store, storeKeys: storeKeys });
   }
 });
@@ -32,25 +38,25 @@ test("initial status", function() {
 
 // ..........................................................
 // LENGTH
-// 
+//
 
 test("should pass through length", function() {
-  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');  
+  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');
 });
 
 test("changing storeKeys length should change length of rec array also", function() {
 
   var oldlen = recs.get('length');
-  
+
   storeKeys.pushObject(SC.Store.generateStoreKey()); // change length
-  
+
   ok(storeKeys.length > oldlen, 'precond - storeKeys.length should have changed');
-  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');    
+  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');
 });
 
 // ..........................................................
 // objectAt
-// 
+//
 
 test("should materialize record for object", function() {
   equals(storeKeys[0], storeKey, 'precond - storeKeys[0] should be storeKey');
@@ -63,67 +69,70 @@ test("reading past end of array length should return undefined", function() {
 
 test("modifying the underlying storeKey should change the returned materialized record", function() {
   // read record once to make it materialized
-  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
-  
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');
+
   // create a new record.
   SC.RunLoop.begin();
-  var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
+  var rec3 = store.createRecord(SC.Record, { foo: "rec3" });
   SC.RunLoop.end();
 
-  var storeKey2 = rec2.get('storeKey');
-  
+  var storeKey3 = rec3.get('storeKey');
+
   // add to beginning of storeKey array
-  storeKeys.unshiftObject(storeKey2);
-  equals(recs.get('length'), 2, 'should now have length of 2');
-  equals(recs.objectAt(0), rec2, 'objectAt(0) should return new record');
-  equals(recs.objectAt(1), rec, 'objectAt(1) should return old record');
+  storeKeys.unshiftObject(storeKey3);
+  equals(recs.get('length'), 3, 'should now have length of 3');
+  equals(recs.objectAt(0), rec3, 'objectAt(0) should return new record');
+  equals(recs.objectAt(1), rec, 'objectAt(1) should return old record 1');
+  equals(recs.objectAt(2), rec2, 'objectAt(2) should return old record 2');
 });
 
 test("reading a record not loaded in store should trigger retrieveRecord", function() {
   var callCount = 0;
 
-  // patch up store to record a call and to make it look like data is not 
+  // patch up store to record a call and to make it look like data is not
   // loaded.
   store.removeDataHash(storeKey, SC.Record.EMPTY);
   store.retrieveRecord = function() { callCount++; };
-  
+
   equals(store.peekStatus(storeKeys.objectAt(0)), SC.Record.EMPTY, 'precond - storeKey must not be loaded');
-  
+
   var rec = recs.objectAt(0);
   equals(callCount, 1, 'store.retrieveRecord() should have been called');
 });
 
 // ..........................................................
 // replace()
-// 
+//
 
 test("adding a record to the record array should pass through storeKeys", function() {
   // read record once to make it materialized
-  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
-  
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');
+
   // create a new record.
   SC.RunLoop.begin();
-  var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
+  var rec3 = store.createRecord(SC.Record, { foo: "rec3" });
   SC.RunLoop.end();
-  
-  var storeKey2 = rec2.get('storeKey');
-  
+
+  var storeKey3 = rec3.get('storeKey');
+
   // add record to beginning of record array
-  recs.unshiftObject(rec2);
-  
+  recs.unshiftObject(rec3);
+
   // verify record array
-  equals(recs.get('length'), 2, 'should now have length of 2');
-  equals(recs.objectAt(0), rec2, 'recs.objectAt(0) should return new record');
-  equals(recs.objectAt(1), rec, 'recs.objectAt(1) should return old record');
-  
+  equals(recs.get('length'), 3, 'should now have length of 3');
+  equals(recs.objectAt(0), rec3, 'recs.objectAt(0) should return new record');
+  equals(recs.objectAt(1), rec, 'recs.objectAt(1) should return old record 1');
+  equals(recs.objectAt(2), rec2, 'recs.objectAt(2) should return old record 2');
+
   // verify storeKeys
-  equals(storeKeys.objectAt(0), storeKey2, 'storeKeys[0] should return new storeKey');
-  equals(storeKeys.objectAt(1), storeKey, 'storeKeys[1] should return old storeKey');
+  equals(storeKeys.objectAt(0), storeKey3, 'storeKeys[0] should return new storeKey');
+  equals(storeKeys.objectAt(1), storeKey, 'storeKeys[1] should return old storeKey 1');
+  equals(storeKeys.objectAt(2), storeKey2, 'storeKeys[2] should return old storeKey 2');
 });
 
 // ..........................................................
 // Property Observing
-// 
+//
 
 test("changing the underlying storeKeys should notify observers of records", function() {
 
@@ -132,8 +141,8 @@ test("changing the underlying storeKeys should notify observers of records", fun
     cnt: 0,
     observer: function() { this.cnt++; }
   });
-  recs.addObserver('[]', obj, obj.observer); 
-  
+  recs.addObserver('[]', obj, obj.observer);
+
   // now modify storeKeys
   storeKeys.pushObject(SC.Store.generateStoreKey());
   equals(obj.cnt, 1, 'observer should have fired after changing storeKeys');
@@ -145,7 +154,7 @@ test("swapping storeKey array should change recordArray and observers", function
   SC.RunLoop.begin();
   var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
   SC.RunLoop.end();
-  
+
   var storeKey2 = rec2.get('storeKey');
   var storeKeys2 = [storeKey2];
 
@@ -154,24 +163,36 @@ test("swapping storeKey array should change recordArray and observers", function
     cnt: 0,
     observer: function() { this.cnt++; }
   });
-  recs.addObserver('[]', obj, obj.observer); 
-  
+  recs.addObserver('[]', obj, obj.observer);
+
   // read record once to make it materialized
-  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
-  
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');
+
   // now swap storeKeys
   obj.cnt = 0 ;
   recs.set('storeKeys', storeKeys2);
-  
+
   // verify observer fired and record changed
   equals(obj.cnt, 1, 'observer should have fired after swap');
   equals(recs.objectAt(0), rec2, 'recs.objectAt(0) should return new rec');
-  
+
   // modify storeKey2, make sure observer fires and content changes
   obj.cnt = 0;
   storeKeys2.unshiftObject(storeKey);
   equals(obj.cnt, 1, 'observer should have fired after edit');
   equals(recs.get('length'), 2, 'should reflect new length');
-  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should return pushed rec');  
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should return pushed rec');
+
+});
+
+test("find works with query", function(){
+  var filtered = recs.find(SC.Query.create({ conditions: "foo = 'bar'" }));
+
+  equals(filtered.get('length'), 1);
+  equals(filtered.objectAt(0), rec);
+});
 
+test("find works as enumerable", function(){
+  var filtered = recs.find(function(r){ return r.get('foo') === 'bar'; });
+  equals(filtered, rec);
 });