lanes 0.1.9 → 0.1.9.5

data/spec/lanes/models/CollectionSpec.coffee

@@ -1,23 +1,28 @@
 describe "Lanes.Models.Collection", ->
 
 
-    it "it triggers promise on loading", (done)->
-        Model = Lanes.Test.DummyModel
+    it "it triggers promise on loading", (done) ->
+        Model = Lanes.Test.defineModel
+            props: { id: 'integer', title: 'string' }
+
         syncSucceedWith([
             { id: 1, title: 'first value'  }
             { id: 2, title: 'second value' }
         ])
-        collection = Model.where( name: 'foo' )
+        collection = Model.where(name: 'foo')
+        expect(collection.requestInProgress).toBe(true)
         collection.whenLoaded ->
             expect( collection.isLoaded() ).toEqual( true )
             done()
 
     it "triggers length when changed", ->
-        collection = new Lanes.Test.DummyModel.Collection
+        Model = Lanes.Test.defineModel
+            props: { id: 'integer', title: 'string' }
+
+        collection = new Model.Collection
         spy = jasmine.createSpy('onLengthChange')
         collection.on("change:length", spy)
         model = collection.add({ id: 1, title: 'first' })
-        expect(model).toEqual(jasmine.any(Lanes.Test.DummyModel))
         expect(spy).toHaveBeenCalled()
         spy.calls.reset()
         collection.remove(model)
@@ -26,22 +31,18 @@ describe "Lanes.Models.Collection", ->
         collection.reset([{ id:11, title: 'last'}])
         expect(spy).toHaveBeenCalled()
 
-
-    it "caches", (done)->
+    it "reads from caches", (done) ->
         model = Lanes.Test.makeModel({
-            cacheDuration: [1,'day']
+            cacheDuration: [1, 'day']
+            api_path: 'model-cache'
             props: { id: 'integer', title: 'string' }
-        })
-        syncSucceedWith([
+        }, {id: 1})
+        Lanes.Models.ServerCache.CACHE["/model-cache"] = [
             { id: 1, title: 'first value'  }
             { id: 2, title: 'second value' }
-        ])
+        ]
         collection = new model.constructor.Collection
         collection.fetch().then ->
-            expect(collection.length).toEqual 2
-            expect(Lanes.Models.Sync.perform).toHaveBeenCalled()
-            Lanes.Models.Sync.perform.calls.reset()
-            collection.fetch().then ->
-                expect(Lanes.Models.Sync.perform).not.toHaveBeenCalled()
-                expect(collection.length).toEqual 2
-                done()
+            expect(collection.length).toEqual(2)
+            expect(collection.first().title).toEqual('first value')
+            done()

data/spec/lanes/models/EnumMapSpec.coffee

@@ -14,7 +14,7 @@ describe "Lanes.Models.EnumMap", ->
 
         },{ id: 123 })
 
-    xit "sets up enums", ->
+    it "sets up enums", ->
         expect(model.is_open).toEqual(false)
         model.state = 1
         expect(model.is_open).toEqual(true)

data/spec/lanes/models/PubSubSpec.coffee

@@ -1,21 +1,23 @@
-
 describe "Lanes.Model.PubSub", ->
-        
+
     it "checks in/out a model when it binds to a view", ->
-        view  = new Lanes.Test.DummyView
-        model = new Lanes.Test.DummyModel(id:1)
-        spyOn(Lanes.Models.PubSub,'add').and.callThrough()
-        spyOn(Lanes.Models.PubSub,'remove')
-        view.model = model
+        spyOn(Lanes.Models.PubSub, 'add').and.callThrough()
+        spyOn(Lanes.Models.PubSub, 'remove')
+        model = Lanes.Test.makeModel({
+            props: { id: 'integer', foo: 'string' }
+        }, { id: 1, foo: 'bar' })
+        component = Lanes.Test.makeComponent({}, model: model)
         expect(Lanes.Models.PubSub.add).toHaveBeenCalledWith(model)
-        expect(Lanes.Vendor.MessageBus.subscribe)
-            .toHaveBeenCalledWith("/test/1", jasmine.any(Function))
-        view.unset('model')
+        component.wrapper.destroy()
         expect(Lanes.Models.PubSub.remove).toHaveBeenCalledWith(model)
 
     it "can retrieve a model after checkin", ->
-        model = new Lanes.Test.DummyModel(id: 11, name:'bar')
-        Lanes.Models.PubSub.add(model)
-        checkin = Lanes.Models.PubSub.instanceFor(Lanes.Test.DummyModel, 11)
-        expect(checkin).toEqual(model)
-        
+        Model = Lanes.Test.defineModel({
+            props: { id: 'integer', foo: 'string' }
+        })
+
+        record = new Model(id: 11, foo: 'bar')
+
+        Lanes.Models.PubSub.add(record)
+        checkin = Lanes.Models.PubSub.instanceFor(Model, 11)
+        expect(checkin).toEqual(record)

data/spec/lanes/models/SyncSpec.coffee

@@ -0,0 +1,28 @@
+describe "Lanes.Models.Sync", ->
+
+    it "it can encode retreival options", (done) ->
+        calledWithUrl = ""
+        spyOn(Lanes.Vendor, 'xhr').and.callFake( (options, cb) ->
+            calledWithUrl = options.url
+            console.dir options
+            cb(false, {}, "{}")
+        )
+
+        options =
+            url: 'endpoint'
+            query: { foo: 'bar' }
+            fields: ['foo', 'bar']
+            with:   'bar_finder_method'
+            include: ['extra_special_values', 'secrets']
+            order: {'foo', 'desc'}
+            limit: 100
+            start: 2
+            format: 'array'
+
+        Lanes.Models.Sync.restorePerform ->
+            Lanes.Models.Sync.perform('GET', options).then (a,b,c)->
+                expect(Lanes.Vendor.xhr).toHaveBeenCalled()
+                expect(calledWithUrl)
+                    .toEqual("endpoint.json?q[foo]=bar&f[]=foo&f[]=bar&w=bar_finder_method&i[]=extra_special_values&i[]=secrets&o[foo]=foo&o[desc]=desc&l=100&s=2&df=array")
+
+                done()

data/spec/lanes/models/UserSpec.coffee

@@ -0,0 +1,17 @@
+describe "Lanes.Model.User", ->
+
+    it "saves callbacks across users", ->
+        spy = jasmine.createSpy('callbackSpy')
+        Lanes.current_user.on("change", spy)
+        #expect( _.keys(Lanes.Models.UserEvents.CALLBACKS).length ).toEqual(2)
+
+        testuser = Lanes.Test.makeModel({
+            session:
+                isLoggedIn: 'bool'
+            canRead: -> true
+        })
+        Lanes.current_user = testuser
+
+        Lanes.current_user.isLoggedIn = false
+
+        expect(spy).toHaveBeenCalled()

data/spec/lanes/react/mixins/DataSpec.coffee

@@ -0,0 +1,72 @@
+describe "Lanes.React.DataMixin", ->
+
+    it "fires setState for a model", ->
+        model = Lanes.Test.makeModel
+            props:
+                id: 'integer'
+                foo: 'string'
+        comp = Lanes.Test.makeComponent({}, model: model)
+        spyOn(comp, 'setState')
+        model.foo = "bar"
+        expect(comp.setState).toHaveBeenCalledWith( model: model )
+
+    it "fires setState for a collection", ->
+        collection = Lanes.Test.makeCollection()
+        comp = Lanes.Test.makeComponent({}, collection: collection)
+        spyOn(comp, 'setState')
+        collection.add([{}])
+        expect(comp.setState).toHaveBeenCalledWith( collection: collection )
+
+    it "obeys global pubsub settings", ->
+        spyOn(Lanes.Models.PubSub, 'add').and.callThrough()
+        model = Lanes.Test.makeModel({
+            props: { id: 'integer', foo: 'string' }
+        }, { id: 1, foo: 'bar' })
+        component = Lanes.Test.makeComponent({pubsub: false}, model: model)
+        expect(Lanes.Models.PubSub.add).not.toHaveBeenCalled()
+
+    it "obeys per-object pubsub settings", ->
+        spyOn(Lanes.Models.PubSub, 'add').and.callThrough()
+        model = Lanes.Test.makeModel({
+            props: { id: 'integer', foo: 'string' }
+        }, {id: 1, foo: 'bar' })
+
+        component = Lanes.Test.makeComponent({pubsub: {model: false}}, model: model)
+        expect(Lanes.Models.PubSub.add).not.toHaveBeenCalled()
+
+    it "can listen to only specific events", ->
+        model = Lanes.Test.makeModel
+            props:
+                foo: 'string'
+                bar: 'string'
+        comp = Lanes.Test.makeComponent({
+            bindDataEvents:
+                model: 'change:bar'
+        }, {
+            model: model
+        })
+        spyOn(comp, 'setState')
+        model.foo = "bar"
+        expect(comp.setState).not.toHaveBeenCalled()
+        model.bar = "foo"
+        expect(comp.setState).toHaveBeenCalledWith( model: model )
+
+    it "can rebind events", ->
+        Model = Lanes.Test.defineModel
+            props:
+                foo: 'string', bar: 'string'
+        m1 = new Model
+        m2 = new Model
+        comp = Lanes.Test.makeComponent({}, {
+            model: m1
+        })
+        spyOn(comp, 'setState')
+        m1.foo = "bar"
+        expect(comp.setState).toHaveBeenCalled()
+
+        comp.data.rebind(model: m2)
+        comp.setState.calls.reset()
+        m1.foo = "a different bar"
+        expect(comp.setState).not.toHaveBeenCalled()
+        m2.foo = "bar"
+        expect(comp.setState).toHaveBeenCalled()

data/spec/lanes/screens/DefinitionsSpec.coffee

@@ -0,0 +1,33 @@
+describe "Lanes.Screens.Definitions", ->
+    orig_user = Lanes.current_user
+    afterEach ->
+        Lanes.current_user = orig_user
+        delete Lanes.Test.DefinitionTestModel
+
+    it "resets caches when user login status changes", ->
+
+        testuser = Lanes.Test.makeModel({
+            session:
+                isLoggedIn: 'bool'
+            canRead: -> true
+        })
+        Lanes.current_user = testuser
+        Lanes.Test.DefinitionTestModel = Lanes.Test.defineModel({
+            props: { id: 'integer', foo: 'string' }
+        })
+        expect(Lanes.current_user).not.toBe(null)
+        Lanes.Screens.Definitions.groups.add( id: 'foo' )
+        Lanes.Screens.Definitions.register(
+            group_id: 'foo', model: 'Lanes.Test.DefinitionTestModel', id: 'screen'
+        )
+        group = Lanes.Screens.Definitions.groups.first()
+        expect(group).not.toBe(null)
+
+        expect(Lanes.Screens.Definitions.groups.available().length).toEqual(1)
+        expect( group.screens().length ).toEqual(1)
+
+        Lanes.current_user.canRead = -> false
+        Lanes.current_user.isLoggedIn = false
+
+        expect( group.screens().length ).toEqual(0)
+        expect( Lanes.Screens.Definitions.groups.available().length ).toEqual(0)

data/spec/lanes/views/BaseSpec.coffee

@@ -1,147 +1,147 @@
-describe "Lanes.Views.Base", ->
+# describe "Lanes.Views.Base", ->
 
-    it "fires el change on render", ->
-        spy = jasmine.createSpy()
-        view = Lanes.Test.makeView({
-            template: "<p>hi</p"
-        })
-        view.on("change:el", spy)
-        view.render()
-        expect(spy).toHaveBeenCalled()
+#     it "fires el change on render", ->
+#         spy = jasmine.createSpy()
+#         view = Lanes.Test.makeView({
+#             template: "<p>hi</p"
+#         })
+#         view.on("change:el", spy)
+#         view.render()
+#         expect(spy).toHaveBeenCalled()
 
-    it "renders a template file", ->
-        spy = jasmine.createSpy('view-test').and.callFake ->
-            "<p>a test</p>"
-        Lanes.Templates['/view-test'] = spy
+#     it "renders a template file", ->
+#         spy = jasmine.createSpy('view-test').and.callFake ->
+#             "<p>a test</p>"
+#         Lanes.Templates['/view-test'] = spy
 
-        view = Lanes.Test.makeView({
-            templatePrefix: ''
-            templateName: "view-test"
-        }, { model: new Lanes.Test.DummyModel({name: 'foo'}) } )
-        view.render()
-        expect(spy).toHaveBeenCalledWith( model: { name: 'foo' }, collection: undefined )
-        expect(view.el.innerHTML).toEqual("a test")
+#         view = Lanes.Test.makeView({
+#             templatePrefix: ''
+#             templateName: "view-test"
+#         }, { model: new Lanes.Test.DummyModel({name: 'foo'}) } )
+#         view.render()
+#         expect(spy).toHaveBeenCalledWith( model: { name: 'foo' }, collection: undefined )
+#         expect(view.el.innerHTML).toEqual("a test")
 
-    it "renders a template string", ->
-        view = Lanes.Test.makeView({
-            template: "<p>hello test</p"
-        })
-        expect(view.template).toEqual "<p>hello test</p"
-        view.render()
-        expect(view.el.tagName).toEqual("P")
-        expect(view.el.innerHTML).toEqual("hello test")
+#     it "renders a template string", ->
+#         view = Lanes.Test.makeView({
+#             template: "<p>hello test</p"
+#         })
+#         expect(view.template).toEqual "<p>hello test</p"
+#         view.render()
+#         expect(view.el.tagName).toEqual("P")
+#         expect(view.el.innerHTML).toEqual("hello test")
 
-    it "listens to domEvents", ->
-        spy = jasmine.createSpy('onClick')
-        el = _.el( 'div',{id: 'testdiv'} )
-        view = Lanes.Test.makeView({
-            domEvents: { "click #mylink": 'onClick' }
-            template: "<div>text,text,text<a id='mylink'>click me</a>mor text</div>"
-            onClick: spy
-        },{el: el})
-        expect(view.domEvents["click #mylink"]).toEqual('onClick')
-        view.render()
-        view.$('a').trigger('click',22)
-        expect(spy).toHaveBeenCalledWith(jasmine.any(Object),22)
+#     it "listens to domEvents", ->
+#         spy = jasmine.createSpy('onClick')
+#         el = _.el( 'div',{id: 'testdiv'} )
+#         view = Lanes.Test.makeView({
+#             domEvents: { "click #mylink": 'onClick' }
+#             template: "<div>text,text,text<a id='mylink'>click me</a>mor text</div>"
+#             onClick: spy
+#         },{el: el})
+#         expect(view.domEvents["click #mylink"]).toEqual('onClick')
+#         view.render()
+#         view.$('a').trigger('click',22)
+#         expect(spy).toHaveBeenCalledWith(jasmine.any(Object),22)
 
-    it "updates from bindings", ->
-        model = new Lanes.Test.DummyModel({ name: "Bob" })
-        view = Lanes.Test.makeView({
-            bindings: {
-                "model.name": { hook: 'link' }
-                "model.url":  { type:'attribute', name: 'href', hook: 'link' }
-            }
-            template: "<div>text,text,text<a data-hook='link'>click me</a>mor text</div>"
-        }, { model: model })
-        view.render()
-        expect( view.$('a').text() ).toEqual("Bob")
-        model.name="Ralph"
-        model.url = 'http://lanesframework.org/'
-        expect( view.$('a').text() ).toEqual("Ralph")
-        expect( view.$('a').attr('href') ).toEqual( model.url )
+#     it "updates from bindings", ->
+#         model = new Lanes.Test.DummyModel({ name: "Bob" })
+#         view = Lanes.Test.makeView({
+#             bindings: {
+#                 "model.name": { hook: 'link' }
+#                 "model.url":  { type:'attribute', name: 'href', hook: 'link' }
+#             }
+#             template: "<div>text,text,text<a data-hook='link'>click me</a>mor text</div>"
+#         }, { model: model })
+#         view.render()
+#         expect( view.$('a').text() ).toEqual("Bob")
+#         model.name="Ralph"
+#         model.url = 'http://lanesframework.org/'
+#         expect( view.$('a').text() ).toEqual("Ralph")
+#         expect( view.$('a').attr('href') ).toEqual( model.url )
 
-    it "renders subviews", ->
-        class LowerView
-            template: "<h1>Hello from Lower View</h1>"
-            constructor: -> super
-            session: { answer: 'string' }
-        Lanes.Views.Base.extend(LowerView)
-        model = new Lanes.Test.DummyModel
-        view = Lanes.Test.makeView({
-            subviews:
-                lower:
-                    hook: 'lower'
-                    waitFor: 'model.name'
-                    view: LowerView
-            template: "<div>text,text,text<div data-hook='lower'>unmodified</div>More text</div>"
-            subviewOptions: ->{ answer: '42' }
-        }, { model: model })
-        view.render()
-        expect(view.$('[data-hook]').text()).toEqual("unmodified")
-        expect( view.$el.text() ).not.toMatch(/Hello from Lower View/)
-        model.name="Ralph"
-        expect( view.$el.text() ).toMatch(/Hello from Lower View/)
-        expect(view.lower.answer).toEqual('42')
+#     it "renders subviews", ->
+#         class LowerView
+#             template: "<h1>Hello from Lower View</h1>"
+#             constructor: -> super
+#             session: { answer: 'string' }
+#         Lanes.Views.Base.extend(LowerView)
+#         model = new Lanes.Test.DummyModel
+#         view = Lanes.Test.makeView({
+#             subviews:
+#                 lower:
+#                     hook: 'lower'
+#                     waitFor: 'model.name'
+#                     view: LowerView
+#             template: "<div>text,text,text<div data-hook='lower'>unmodified</div>More text</div>"
+#             subviewOptions: ->{ answer: '42' }
+#         }, { model: model })
+#         view.render()
+#         expect(view.$('[data-hook]').text()).toEqual("unmodified")
+#         expect( view.$el.text() ).not.toMatch(/Hello from Lower View/)
+#         model.name="Ralph"
+#         expect( view.$el.text() ).toMatch(/Hello from Lower View/)
+#         expect(view.lower.answer).toEqual('42')
 
-    it "renders collection views", ->
-        class LowerView
-            template: "<h1>Hello from Lower View</h1>"
-            constructor: -> super
-            bindings: { "model.name": { type: "text" } }
-        Lanes.Views.Base.extend(LowerView)
-        collection = new Lanes.Test.DummyModel.Collection
-        view = Lanes.Test.makeView({
-            subviews:
-                lower:
-                    hook: 'lower'
-                    collection: 'collection'
-                    view: LowerView
-            template: "<div>text,text,text<div data-hook='lower'>unmodified</div>More text</div>"
-        }, { collection: collection})
-        view.render()
-        expect(view.$('h1').length).toEqual(0)
-        collection.add([{ name: "One"}, {name: "Two"},{name:"Three"}])
-        expect(view.$('h1').length).toEqual(3)
-        expect(view.$('h1:first').text()).toMatch('One')
+#     it "renders collection views", ->
+#         class LowerView
+#             template: "<h1>Hello from Lower View</h1>"
+#             constructor: -> super
+#             bindings: { "model.name": { type: "text" } }
+#         Lanes.Views.Base.extend(LowerView)
+#         collection = new Lanes.Test.DummyModel.Collection
+#         view = Lanes.Test.makeView({
+#             subviews:
+#                 lower:
+#                     hook: 'lower'
+#                     collection: 'collection'
+#                     view: LowerView
+#             template: "<div>text,text,text<div data-hook='lower'>unmodified</div>More text</div>"
+#         }, { collection: collection})
+#         view.render()
+#         expect(view.$('h1').length).toEqual(0)
+#         collection.add([{ name: "One"}, {name: "Two"},{name:"Three"}])
+#         expect(view.$('h1').length).toEqual(3)
+#         expect(view.$('h1:first').text()).toMatch('One')
 
-    it "caches elements in ui", ->
-        spy = jasmine.createSpy('onClick')
-        view = Lanes.Test.makeView({
-            ui:
-                link: '#linky'
-            domEvents:
-                'click @ui.link': spy
-            template: "<div>text,text,text<a id='linky'>unmodified</a>More text</div>"
-        })
-        view.render()
-        expect(view.ui.link.length).toEqual(1)
-        view.$('a').click()
-        expect(spy).toHaveBeenCalled()
+#     it "caches elements in ui", ->
+#         spy = jasmine.createSpy('onClick')
+#         view = Lanes.Test.makeView({
+#             ui:
+#                 link: '#linky'
+#             domEvents:
+#                 'click @ui.link': spy
+#             template: "<div>text,text,text<a id='linky'>unmodified</a>More text</div>"
+#         })
+#         view.render()
+#         expect(view.ui.link.length).toEqual(1)
+#         view.$('a').click()
+#         expect(spy).toHaveBeenCalled()
 
 
-    it "invokes model events", ->
-        nameSpy = jasmine.createSpy()
-        urlSpy  = jasmine.createSpy()
-        model   = new Lanes.Test.DummyModel
-        view = Lanes.Test.makeView({
-            modelEvents:
-                'change:name': nameSpy
-                'change:url' : 'onURLChange'
-            onURLChange: urlSpy
-        },{ model: model })
+#     it "invokes model events", ->
+#         nameSpy = jasmine.createSpy()
+#         urlSpy  = jasmine.createSpy()
+#         model   = new Lanes.Test.DummyModel
+#         view = Lanes.Test.makeView({
+#             modelEvents:
+#                 'change:name': nameSpy
+#                 'change:url' : 'onURLChange'
+#             onURLChange: urlSpy
+#         },{ model: model })
 
-        model.name="Ralph"
-        expect(nameSpy).toHaveBeenCalled()
+#         model.name="Ralph"
+#         expect(nameSpy).toHaveBeenCalled()
 
 
-    it "invokes collection events", ->
-        eventSpy = jasmine.createSpy('event')
-        view = Lanes.Test.makeView({
-            collectionEvents:
-                all: 'onEvent'
-            onEvent: eventSpy
-            initialize: -> this.collection = new Lanes.Test.DummyModel.Collection
-        })
-        expect(eventSpy).not.toHaveBeenCalled()
-        view.collection.add(new Lanes.Test.DummyModel)
-        expect(eventSpy).toHaveBeenCalled()
+#     it "invokes collection events", ->
+#         eventSpy = jasmine.createSpy('event')
+#         view = Lanes.Test.makeView({
+#             collectionEvents:
+#                 all: 'onEvent'
+#             onEvent: eventSpy
+#             initialize: -> this.collection = new Lanes.Test.DummyModel.Collection
+#         })
+#         expect(eventSpy).not.toHaveBeenCalled()
+#         view.collection.add(new Lanes.Test.DummyModel)
+#         expect(eventSpy).toHaveBeenCalled()