Merge a11e43d into 4a1d8d4

Gruntfile.coffee

@@ -105,5 +105,5 @@ module.exports = ( grunt ) ->
   grunt.loadNpmTasks 'grunt-contrib-watch'
 
   grunt.registerTask 'default', ['watch']
-  grunt.registerTask 'spec',  ['coffee:dist', 'coffee:spec', 'jasmine', 'clean:spec']
+  grunt.registerTask 'spec',  ['clean:spec', 'coffee:dist', 'coffee:spec', 'jasmine', 'clean:spec']
   grunt.registerTask 'build',   ['coffee:dist', 'uglify:dist']

spec/mixins/collectable.coffee

@@ -12,7 +12,47 @@ describe "Tails.Mixins.Collectable", ->
       createModel()
       expect(createModel).toThrow()
 
+    it "should allow the creation of named scopes", ->
+      class Fruit extends @Model
+        @scope 'fresh', where: { rotten: false}
+        @scope 'rotten', where: { rotten: true }
 
+      goodBanana = new Fruit({ rotten: false })
+      badBanana = new Fruit({ rotten: true })
 
+      expect(Fruit.fresh.contains(goodBanana)).toBe(true)
+      expect(Fruit.fresh.contains(badBanana)).toBe(false)
+      expect(Fruit.rotten.contains(goodBanana)).toBe(false)
+      expect(Fruit.rotten.contains(badBanana)).toBe(true)
 
+      goodBanana.set('rotten', true)
+      expect(Fruit.fresh.contains(goodBanana)).toBe(false)
+      expect(Fruit.rotten.contains(goodBanana)).toBe(true)
 
+      Fruit.fresh.add(badBanana)
+      expect(badBanana.get('rotten')).toBe(false)
+      expect(Fruit.fresh.contains(badBanana)).toBe(true)
+      expect(Fruit.rotten.contains(badBanana)).toBe(false)
+
+    it "should allow the creation of anonymous scopes", ->
+      class Fruit extends @Model
+
+      freshFruits = Fruit.scope where: { rotten: false }
+      rottenFruits = Fruit.scope where: { rotten: true }
+
+      goodBanana = new Fruit({ rotten: false })
+      badBanana = new Fruit({ rotten: true })
+
+      expect(freshFruits.contains(goodBanana)).toBe(true)
+      expect(freshFruits.contains(badBanana)).toBe(false)
+      expect(rottenFruits.contains(goodBanana)).toBe(false)
+      expect(rottenFruits.contains(badBanana)).toBe(true)
+
+      goodBanana.set('rotten', true)
+      expect(freshFruits.contains(goodBanana)).toBe(false)
+      expect(rottenFruits.contains(goodBanana)).toBe(true)
+
+      freshFruits.add(badBanana)
+      expect(badBanana.get('rotten')).toBe(false)
+      expect(freshFruits.contains(badBanana)).toBe(true)
+      expect(rottenFruits.contains(badBanana)).toBe(false)

spec/mixins/relations.coffee

@@ -261,6 +261,3 @@ describe "Tails.Mixins.Relations", ->
       fruit = new Fruit({id: 1, container_id: 1})
 
       expect(basket.get('fruits').contains(fruit)).toBe(true)
-
-
-

src/mixins/collectable.coffee

@@ -23,6 +23,42 @@ Tails.Mixins.Collectable =
     get: ( id ) ->
       @collection().get(id) or new @ id: id
 
+    scope: ( name, options ) ->
+      options = name unless typeof name is 'string'
+
+      collection = new Tails.Collection @collection().where(options.where), { model: @, parent: @ }
+
+      for attr, value of options.where
+        @collection().on "change:#{attr}", ( model, v ) =>
+          if v isnt value and collection.contains model
+            collection.remove model
+
+          else if v is value and not collection.contains model
+            collection.add model
+
+        # When the model is added to the all() collection, the change events
+        # on the foreign key may have already been triggered. So we check each
+        # added model if it has us as its foreign key.
+        @collection().on "add", ( model ) =>
+          if model.get(attr) is value and not collection.contains model
+            collection.add model
+
+        @collection().on "remove", ( model ) =>
+          if model.get(attr) is value and collection.contains model
+            collection.remove model
+
+        # Watch our own collection for changes.
+        collection.on "add", ( model ) =>
+          unless model.get(attr) is value
+            model.set(attr, value)
+
+        collection.on "remove", ( model ) =>
+          if model.get(attr) is value
+            model.set(attr, undefined)
+
+      @[name] = collection if name?
+      return collection
+
     extended: ( ) ->
       methods = [
         'forEach', 'each', 'map', 'collect', 'reduce', 'foldl',

src/mixins/relations.coffee

@@ -66,46 +66,8 @@ Tails.Mixins.Relations =
       for foreignName, klass of _(relations).omit('foreignKey')
         do ( foreignKey, foreignName, klass ) =>
           foreignKey ||= inflection.foreign_key(@constructor.name)
-
-          # Create the collection of relations
-          collection = new Tails.Collection null, { model: klass, parent: @ }
-          @set foreignName, collection
-
-          # Find all models of klass that have already set us as their relation.
-          collection.add(klass.find ( model ) => model.get(foreignKey) is @id)
-
-          # Listen to the all() collection of the related class for changes in
-          # foreign keys. If they're not in our collection and they set their
-          # foreign key to us, add them. If they are in our collection and
-          # set their foreign key to something else, remove them.
-          klass.on "change:#{foreignKey}", ( model, id ) =>
-            if id isnt @id and collection.contains model
-              collection.remove model
-
-            # We have to check if the collection is currently syncing. This
-            # is necessary because else
-            else if id is @id and not collection.contains model
-              collection.add model
-
-          # When the model is added to the all() collection, the change events
-          # on the foreign key may have already been triggered. So we check each
-          # added model if it has us as its foreign key.
-          klass.on "add", ( model ) =>
-            if model.get(foreignKey) is @id and not collection.contains model
-              collection.add model
-
-          klass.on "remove", ( model ) =>
-            if model.get(foreignKey) is @id and collection.contains model
-              collection.remove model
-
-          # Watch our own collection for changes.
-          collection.on "add", ( model ) =>
-            unless model.get(foreignKey) is @id
-              model.set(foreignKey, @id)
-
-          collection.on "remove", ( model ) =>
-            if model.get(foreignKey) is @id
-              model.set(foreignKey, undefined)
+          (selector = {})[foreignKey] = @id
+          @set foreignName, klass.scope where: selector
 
   ClassMethods:
     belongsTo: ( relations ) ->