All tests except persistence pass

lib/model.js

@@ -681,7 +681,7 @@ function matchQueryPart (obj, queryKey, queryValue, treatObjAsValue) {
   var objValue = getDotValue(obj, queryKey)
     , i, keys, firstChars, dollarFirstChars;
 
-  // Check if the object value is an array
+  // Check if the value is an array if we don't force a treatment as value
   if (util.isArray(objValue) && !treatObjAsValue) {
     // Check if we are using an array-specific comparison function
     if (queryValue !== null && typeof queryValue === 'object' && !util.isRegExp(queryValue)) {

test/model.test.js

@@ -1081,11 +1081,12 @@ describe('Model', function () {
     });
 
     
-    describe.only('Query operator array $size', function () {
+    describe('Query operator array $size', function () {
 
         it('Can query on the size of an array field', function () {
           // Non nested documents
           model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens": { $size: 0 } }).should.equal(false);
+          model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens": { $size: 1 } }).should.equal(false);
           model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens": { $size: 2 } }).should.equal(false);
           model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens": { $size: 3 } }).should.equal(true);
             
@@ -1094,6 +1095,12 @@ describe('Model', function () {
           model.match({ hello: 'world', description: { satellites: ['Moon', 'Hubble'], diameter: 6300 } }, { "description.satellites": { $size: 1 } }).should.equal(false);
           model.match({ hello: 'world', description: { satellites: ['Moon', 'Hubble'], diameter: 6300 } }, { "description.satellites": { $size: 2 } }).should.equal(true);
           model.match({ hello: 'world', description: { satellites: ['Moon', 'Hubble'], diameter: 6300 } }, { "description.satellites": { $size: 3 } }).should.equal(false);
+
+          // Using a projected array
+          model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens.names": { $size: 0 } }).should.equal(false);
+          model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens.names": { $size: 1 } }).should.equal(false);
+          model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens.names": { $size: 2 } }).should.equal(false);
+          model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens.names": { $size: 3 } }).should.equal(true);
         });
 
         it('$size operator works with empty arrays', function () {
@@ -1102,12 +1109,20 @@ describe('Model', function () {
           model.match({ childrens: [] }, { "childrens": { $size: 3 } }).should.equal(false);
         });
 
-        it('Should throw an error if a query operator is used without being applied to an array and comparing to an integer', function () {
-          model.match({ a: 5 }, { a: { $size: 1 } });
+        it('Should throw an error if a query operator is used without comparing to an integer', function () {
           (function () { model.match({ a: [1, 5] }, { a: { $size: 1.4 } }); }).should.throw();
           (function () { model.match({ a: [1, 5] }, { a: { $size: 'fdf' } }); }).should.throw();
         });
 
+        it('Using $size operator on a non-array field should prevent match but not throw', function () {
+          model.match({ a: 5 }, { a: { $size: 1 } }).should.equal(false);
+        });
+        
+        it('Can use $size several times in the same matcher', function () {
+          model.match({ childrens: [ 'Riri', 'Fifi', 'Loulou' ] }, { "childrens": { $size: 3, $size: 3 } }).should.equal(true);
+          model.match({ childrens: [ 'Riri', 'Fifi', 'Loulou' ] }, { "childrens": { $size: 3, $size: 4 } }).should.equal(false);   // Of course this can never be true
+        });
+        
     });
     
 
@@ -1203,6 +1218,20 @@ describe('Model', function () {
         model.match({ childrens: [ { name: "Huey", age: 3 }, { name: "Dewey", age: 7 }, { name: "Louie", age: 12 } ] }, { "childrens.3.name": 'Louie' }).should.equal(false);
       });
       
+      it('A single array-specific operator and the query is treated as array specific', function () {
+        (function () { model.match({ childrens: [ 'Riri', 'Fifi', 'Loulou' ] }, { "childrens": { "Fifi": true, $size: 3 } })}).should.throw();
+      });
+      
+      it('Can mix queries on array fields and non array filds with array specific operators', function () {
+        model.match({ uncle: 'Donald', nephews: [ 'Riri', 'Fifi', 'Loulou' ] }, { nephews: { $size: 2 }, uncle: 'Donald' }).should.equal(false);
+        model.match({ uncle: 'Donald', nephews: [ 'Riri', 'Fifi', 'Loulou' ] }, { nephews: { $size: 3 }, uncle: 'Donald' }).should.equal(true);
+        model.match({ uncle: 'Donald', nephews: [ 'Riri', 'Fifi', 'Loulou' ] }, { nephews: { $size: 4 }, uncle: 'Donald' }).should.equal(false);
+
+        model.match({ uncle: 'Donals', nephews: [ 'Riri', 'Fifi', 'Loulou' ] }, { nephews: { $size: 3 }, uncle: 'Picsou' }).should.equal(false);
+        model.match({ uncle: 'Donald', nephews: [ 'Riri', 'Fifi', 'Loulou' ] }, { nephews: { $size: 3 }, uncle: 'Donald' }).should.equal(true);
+        model.match({ uncle: 'Donald', nephews: [ 'Riri', 'Fifi', 'Loulou' ] }, { nephews: { $size: 3 }, uncle: 'Daisy' }).should.equal(false);
+      });
+      
     });
 
   });   // ==== End of 'Querying' ==== //

test/persistence.test.js

@@ -552,7 +552,7 @@ describe('Persistence', function () {
     // That depends on the machine and the load on the machine when the tests are run
     // It is timed for my machine with nothing else running but may not work as expected on others (it will not fail but may not be a proof)
     // Every new version of NeDB passes it on my machine before rtelease
-    it.skip('If system crashes during a loadDatabase, the former version is not lost', function (done) {
+    it('If system crashes during a loadDatabase, the former version is not lost', function (done) {
       var cp, N = 150000, toWrite = "", i;
       
       // Ensuring the state is clean